From e9328bfa3aa820c4af25e5bae4da9f5cee6557a3 Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Mon, 19 May 2025 14:48:41 -0400 Subject: [PATCH 01/65] Adding langfuse usage details for cached tokens --- litellm/integrations/langfuse/langfuse.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/litellm/integrations/langfuse/langfuse.py b/litellm/integrations/langfuse/langfuse.py index d0472ee6383..ccc072149cc 100644 --- a/litellm/integrations/langfuse/langfuse.py +++ b/litellm/integrations/langfuse/langfuse.py @@ -638,6 +638,7 @@ class LangFuseLogger: generation_id = None usage = None + usage_details = None if response_obj is not None: if ( hasattr(response_obj, "id") @@ -654,6 +655,13 @@ class LangFuseLogger: "completion_tokens": _usage_obj.completion_tokens, "total_cost": cost if self._supports_costs() else None, } + usage_details = { + "input": _usage_obj.prompt_tokens, + "output": _usage_obj.completion_tokens, + "cache_creation_input_tokens": _usage_obj.get('cache_creation_input_tokens', 0), + "cache_read_input_tokens": _usage_obj.get('cache_read_input_tokens', 0) + } + generation_name = clean_metadata.pop("generation_name", None) if generation_name is None: # if `generation_name` is None, use sensible default values @@ -686,6 +694,7 @@ class LangFuseLogger: "input": input if not mask_input else "redacted-by-litellm", "output": output if not mask_output else "redacted-by-litellm", "usage": usage, + "usage_details": usage_details, "metadata": log_requester_metadata(clean_metadata), "level": level, "version": clean_metadata.pop("version", None), From d47ad69a1b2d006fbc15acea12bc47cc9d330bc1 Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 10:43:08 -0400 Subject: [PATCH 02/65] Added typed dict for LangfuseUsageDetails --- litellm/integrations/langfuse/langfuse.py | 2 +- litellm/types/integrations/langfuse.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/litellm/integrations/langfuse/langfuse.py b/litellm/integrations/langfuse/langfuse.py index f4d1a1f79c4..17e15e0b03c 100644 --- a/litellm/integrations/langfuse/langfuse.py +++ b/litellm/integrations/langfuse/langfuse.py @@ -659,7 +659,7 @@ class LangFuseLogger: "completion_tokens": _usage_obj.completion_tokens, "total_cost": cost if self._supports_costs() else None, } - usage_details = { + usage_details : Optional[LangfuseUsageDetails] = { "input": _usage_obj.prompt_tokens, "output": _usage_obj.completion_tokens, "cache_creation_input_tokens": _usage_obj.get('cache_creation_input_tokens', 0), diff --git a/litellm/types/integrations/langfuse.py b/litellm/types/integrations/langfuse.py index ecf42d8cd47..c19cd98d162 100644 --- a/litellm/types/integrations/langfuse.py +++ b/litellm/types/integrations/langfuse.py @@ -5,3 +5,10 @@ class LangfuseLoggingConfig(TypedDict): langfuse_secret: Optional[str] langfuse_public_key: Optional[str] langfuse_host: Optional[str] + + +class LangfuseUsageDetails(TypedDict): + input: Optional[int] + output: Optional[int] + cache_creation_input_tokens: Optional[int] + cache_read_input_tokens: Optional[int] From a30fd5c2ad59682d250493996e55327abd5e645b Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 10:51:59 -0400 Subject: [PATCH 03/65] Fixing lint errors with LangfuseUsageDetails --- litellm/integrations/langfuse/langfuse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/integrations/langfuse/langfuse.py b/litellm/integrations/langfuse/langfuse.py index 17e15e0b03c..001e79cf802 100644 --- a/litellm/integrations/langfuse/langfuse.py +++ b/litellm/integrations/langfuse/langfuse.py @@ -642,7 +642,7 @@ class LangFuseLogger: generation_id = None usage = None - usage_details = None + usage_details : Optional[LangfuseUsageDetails] = None if response_obj is not None: if ( hasattr(response_obj, "id") From 90c54d688a4b290312c79a5c50cfbb227aa09670 Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 11:03:14 -0400 Subject: [PATCH 04/65] Fixing lint errors with LangfuseUsageDetails again --- litellm/integrations/langfuse/langfuse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/integrations/langfuse/langfuse.py b/litellm/integrations/langfuse/langfuse.py index 001e79cf802..a98771387c0 100644 --- a/litellm/integrations/langfuse/langfuse.py +++ b/litellm/integrations/langfuse/langfuse.py @@ -659,7 +659,7 @@ class LangFuseLogger: "completion_tokens": _usage_obj.completion_tokens, "total_cost": cost if self._supports_costs() else None, } - usage_details : Optional[LangfuseUsageDetails] = { + usage_details = { "input": _usage_obj.prompt_tokens, "output": _usage_obj.completion_tokens, "cache_creation_input_tokens": _usage_obj.get('cache_creation_input_tokens', 0), From bd0369dd887e3fb9f630c6e25d6962f42635a0b5 Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 13:35:21 -0400 Subject: [PATCH 05/65] Using typed dict in usage_details --- litellm/integrations/langfuse/langfuse.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/litellm/integrations/langfuse/langfuse.py b/litellm/integrations/langfuse/langfuse.py index a98771387c0..f116eb8041b 100644 --- a/litellm/integrations/langfuse/langfuse.py +++ b/litellm/integrations/langfuse/langfuse.py @@ -642,7 +642,7 @@ class LangFuseLogger: generation_id = None usage = None - usage_details : Optional[LangfuseUsageDetails] = None + usage_details = None if response_obj is not None: if ( hasattr(response_obj, "id") @@ -659,12 +659,10 @@ class LangFuseLogger: "completion_tokens": _usage_obj.completion_tokens, "total_cost": cost if self._supports_costs() else None, } - usage_details = { - "input": _usage_obj.prompt_tokens, - "output": _usage_obj.completion_tokens, - "cache_creation_input_tokens": _usage_obj.get('cache_creation_input_tokens', 0), - "cache_read_input_tokens": _usage_obj.get('cache_read_input_tokens', 0) - } + usage_details = LangfuseUsageDetails(input=_usage_obj.prompt_tokens, + output=_usage_obj.completion_tokens, + cache_creation_input_tokens=_usage_obj.get('cache_creation_input_tokens', 0), + cache_read_input_tokens=_usage_obj.get('cache_read_input_tokens', 0)) generation_name = clean_metadata.pop("generation_name", None) if generation_name is None: From 9d73f1e607be57c65c6d8061f060c15c7e92a21d Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 21:23:49 -0400 Subject: [PATCH 06/65] Added unit tests for langfuse usage details integration --- tests/litellm/integrations/test_langfuse.py | 218 ++++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 tests/litellm/integrations/test_langfuse.py diff --git a/tests/litellm/integrations/test_langfuse.py b/tests/litellm/integrations/test_langfuse.py new file mode 100644 index 00000000000..26874d9ba21 --- /dev/null +++ b/tests/litellm/integrations/test_langfuse.py @@ -0,0 +1,218 @@ +import unittest +from unittest.mock import patch, MagicMock +import sys +import os +import datetime + +sys.path.insert(0, os.path.abspath("../..")) +from litellm.integrations.langfuse.langfuse import LangFuseLogger +# Import LangfuseUsageDetails directly from the module where it's defined +from litellm.types.integrations.langfuse import * + + + +class TestLangfuseUsageDetails(unittest.TestCase): + + def setUp(self): + # Set up environment variables for testing + self.env_patcher = patch.dict('os.environ', { + 'LANGFUSE_SECRET_KEY': 'test-secret-key', + 'LANGFUSE_PUBLIC_KEY': 'test-public-key', + 'LANGFUSE_HOST': 'https://test.langfuse.com' + }) + self.env_patcher.start() + + # Create mock objects + self.mock_langfuse_client = MagicMock() + self.mock_langfuse_trace = MagicMock() + self.mock_langfuse_generation = MagicMock() + + # Setup the trace and generation chain + self.mock_langfuse_trace.generation.return_value = self.mock_langfuse_generation + self.mock_langfuse_client.trace.return_value = self.mock_langfuse_trace + + # Mock the langfuse module that's imported locally in methods + self.langfuse_module_patcher = patch.dict('sys.modules', {'langfuse': MagicMock()}) + self.mock_langfuse_module = self.langfuse_module_patcher.start() + + # Create a mock for the langfuse module with version + self.mock_langfuse = MagicMock() + self.mock_langfuse.version = MagicMock() + self.mock_langfuse.version.__version__ = "3.0.0" # Set a version that supports all features + + # Mock the Langfuse class + self.mock_langfuse_class = MagicMock() + self.mock_langfuse_class.return_value = self.mock_langfuse_client + + # Set up the sys.modules['langfuse'] mock + sys.modules['langfuse'] = self.mock_langfuse + sys.modules['langfuse'].Langfuse = self.mock_langfuse_class + + # Mock the Langfuse client + self.mock_langfuse_client = MagicMock() + self.mock_langfuse_trace = MagicMock() + self.mock_langfuse_generation = MagicMock() + + # Setup the trace and generation chain + self.mock_langfuse_trace.generation.return_value = self.mock_langfuse_generation + self.mock_langfuse_client.trace.return_value = self.mock_langfuse_trace + + # Mock the Langfuse class + self.mock_langfuse_class = MagicMock() + self.mock_langfuse_class.return_value = self.mock_langfuse_client + self.mock_langfuse.Langfuse = self.mock_langfuse_class + + # Create the logger + self.logger = LangFuseLogger() + + # Add the log_event_on_langfuse method to the instance + def log_event_on_langfuse(self, kwargs, response_obj, start_time=None, end_time=None, user_id=None, level="DEFAULT", status_message=None): + # This implementation calls _log_langfuse_v2 directly + return self._log_langfuse_v2( + user_id=user_id, + metadata=kwargs.get("litellm_params", {}).get("metadata", {}), + litellm_params=kwargs.get("litellm_params", {}), + output=None, + start_time=start_time, + end_time=end_time, + kwargs=kwargs, + optional_params=kwargs.get("optional_params", {}), + input=None, + response_obj=response_obj, + level=level, + litellm_call_id=kwargs.get("litellm_call_id", None), + print_verbose=True # Add the missing parameter + ) + + # Bind the method to the instance + import types + self.logger.log_event_on_langfuse = types.MethodType(log_event_on_langfuse, self.logger) + + # Make sure _is_langfuse_v2 returns True + def mock_is_langfuse_v2(self): + return True + + self.logger._is_langfuse_v2 = types.MethodType(mock_is_langfuse_v2, self.logger) + + def tearDown(self): + self.env_patcher.stop() + self.langfuse_module_patcher.stop() + + def test_langfuse_usage_details_type(self): + """Test that LangfuseUsageDetails TypedDict is properly defined with the correct fields""" + # Create an instance of LangfuseUsageDetails + usage_details: LangfuseUsageDetails = { + "input": 10, + "output": 20, + "cache_creation_input_tokens": 5, + "cache_read_input_tokens": 3 + } + + # Verify all fields are present + self.assertEqual(usage_details["input"], 10) + self.assertEqual(usage_details["output"], 20) + self.assertEqual(usage_details["cache_creation_input_tokens"], 5) + self.assertEqual(usage_details["cache_read_input_tokens"], 3) + + # Test with all fields (all fields are required in TypedDict by default) + minimal_usage_details: LangfuseUsageDetails = { + "input": 10, + "output": 20, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0 + } + + self.assertEqual(minimal_usage_details["input"], 10) + self.assertEqual(minimal_usage_details["output"], 20) + + def test_log_langfuse_v2_usage_details(self): + """Test that usage_details in _log_langfuse_v2 is correctly typed and assigned""" + # Create a mock response object with usage information + response_obj = MagicMock() + response_obj.usage = MagicMock() + response_obj.usage.prompt_tokens = 15 + response_obj.usage.completion_tokens = 25 + + # Add the cache token attributes using get method + def mock_get(key, default=None): + if key == 'cache_creation_input_tokens': + return 7 + elif key == 'cache_read_input_tokens': + return 4 + return default + + response_obj.usage.get = mock_get + + # Create kwargs for the log_event method + kwargs = { + "model": "gpt-4", + "messages": [{"role": "user", "content": "Hello"}], + "litellm_params": {"metadata": {}} + } + + # Create start and end times + start_time = datetime.datetime.now() + end_time = start_time + datetime.timedelta(seconds=1) + + # Call the log_event method + with patch.object(self.logger, '_log_langfuse_v2') as mock_log_langfuse_v2: + self.logger.log_event_on_langfuse( + kwargs=kwargs, + response_obj=response_obj, + start_time=start_time, + end_time=end_time + ) + + # Check if _log_langfuse_v2 was called + mock_log_langfuse_v2.assert_called_once() + + # Get the arguments passed to _log_langfuse_v2 + call_args = mock_log_langfuse_v2.call_args[1] + + # Verify response_obj was passed correctly + self.assertEqual(call_args["response_obj"], response_obj) + + def test_langfuse_usage_details_optional_fields(self): + """Test that LangfuseUsageDetails fields are properly defined as Optional""" + # Create an instance with None values for optional fields + usage_details: LangfuseUsageDetails = { + "input": 10, + "output": 20, + "cache_creation_input_tokens": None, + "cache_read_input_tokens": None + } + + # Verify fields can be None + self.assertEqual(usage_details["input"], 10) + self.assertEqual(usage_details["output"], 20) + self.assertIsNone(usage_details["cache_creation_input_tokens"]) + self.assertIsNone(usage_details["cache_read_input_tokens"]) + + def test_langfuse_usage_details_structure(self): + """Test that LangfuseUsageDetails has the correct structure as defined in the commit""" + # This test directly verifies the structure of the TypedDict + # without relying on the LangFuseLogger class + + # Create a dictionary that matches the LangfuseUsageDetails structure + usage_details = { + "input": 15, + "output": 25, + "cache_creation_input_tokens": 7, + "cache_read_input_tokens": 4 + } + + # Verify the structure matches what we expect + self.assertIn("input", usage_details) + self.assertIn("output", usage_details) + self.assertIn("cache_creation_input_tokens", usage_details) + self.assertIn("cache_read_input_tokens", usage_details) + + # Verify the values + self.assertEqual(usage_details["input"], 15) + self.assertEqual(usage_details["output"], 25) + self.assertEqual(usage_details["cache_creation_input_tokens"], 7) + self.assertEqual(usage_details["cache_read_input_tokens"], 4) + + +if __name__ == "__main__": + unittest.main() From 118d15c1c61e26daf0362bc08e13e28a4eafc4f6 Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Wed, 21 May 2025 21:37:23 -0400 Subject: [PATCH 07/65] Improving langfuse usage details unit test --- tests/litellm/integrations/test_langfuse.py | 76 ++++++++++----------- 1 file changed, 35 insertions(+), 41 deletions(-) diff --git a/tests/litellm/integrations/test_langfuse.py b/tests/litellm/integrations/test_langfuse.py index 26874d9ba21..2aa363e5f94 100644 --- a/tests/litellm/integrations/test_langfuse.py +++ b/tests/litellm/integrations/test_langfuse.py @@ -9,10 +9,8 @@ from litellm.integrations.langfuse.langfuse import LangFuseLogger # Import LangfuseUsageDetails directly from the module where it's defined from litellm.types.integrations.langfuse import * - - class TestLangfuseUsageDetails(unittest.TestCase): - + def setUp(self): # Set up environment variables for testing self.env_patcher = patch.dict('os.environ', { @@ -21,50 +19,50 @@ class TestLangfuseUsageDetails(unittest.TestCase): 'LANGFUSE_HOST': 'https://test.langfuse.com' }) self.env_patcher.start() - + # Create mock objects self.mock_langfuse_client = MagicMock() self.mock_langfuse_trace = MagicMock() self.mock_langfuse_generation = MagicMock() - + # Setup the trace and generation chain self.mock_langfuse_trace.generation.return_value = self.mock_langfuse_generation self.mock_langfuse_client.trace.return_value = self.mock_langfuse_trace - + # Mock the langfuse module that's imported locally in methods self.langfuse_module_patcher = patch.dict('sys.modules', {'langfuse': MagicMock()}) self.mock_langfuse_module = self.langfuse_module_patcher.start() - + # Create a mock for the langfuse module with version self.mock_langfuse = MagicMock() self.mock_langfuse.version = MagicMock() self.mock_langfuse.version.__version__ = "3.0.0" # Set a version that supports all features - + # Mock the Langfuse class self.mock_langfuse_class = MagicMock() self.mock_langfuse_class.return_value = self.mock_langfuse_client - + # Set up the sys.modules['langfuse'] mock sys.modules['langfuse'] = self.mock_langfuse sys.modules['langfuse'].Langfuse = self.mock_langfuse_class - + # Mock the Langfuse client self.mock_langfuse_client = MagicMock() self.mock_langfuse_trace = MagicMock() self.mock_langfuse_generation = MagicMock() - + # Setup the trace and generation chain self.mock_langfuse_trace.generation.return_value = self.mock_langfuse_generation self.mock_langfuse_client.trace.return_value = self.mock_langfuse_trace - + # Mock the Langfuse class self.mock_langfuse_class = MagicMock() self.mock_langfuse_class.return_value = self.mock_langfuse_client self.mock_langfuse.Langfuse = self.mock_langfuse_class - + # Create the logger self.logger = LangFuseLogger() - + # Add the log_event_on_langfuse method to the instance def log_event_on_langfuse(self, kwargs, response_obj, start_time=None, end_time=None, user_id=None, level="DEFAULT", status_message=None): # This implementation calls _log_langfuse_v2 directly @@ -83,21 +81,21 @@ class TestLangfuseUsageDetails(unittest.TestCase): litellm_call_id=kwargs.get("litellm_call_id", None), print_verbose=True # Add the missing parameter ) - + # Bind the method to the instance import types self.logger.log_event_on_langfuse = types.MethodType(log_event_on_langfuse, self.logger) - + # Make sure _is_langfuse_v2 returns True def mock_is_langfuse_v2(self): return True - + self.logger._is_langfuse_v2 = types.MethodType(mock_is_langfuse_v2, self.logger) - + def tearDown(self): self.env_patcher.stop() self.langfuse_module_patcher.stop() - + def test_langfuse_usage_details_type(self): """Test that LangfuseUsageDetails TypedDict is properly defined with the correct fields""" # Create an instance of LangfuseUsageDetails @@ -107,13 +105,13 @@ class TestLangfuseUsageDetails(unittest.TestCase): "cache_creation_input_tokens": 5, "cache_read_input_tokens": 3 } - + # Verify all fields are present self.assertEqual(usage_details["input"], 10) self.assertEqual(usage_details["output"], 20) self.assertEqual(usage_details["cache_creation_input_tokens"], 5) self.assertEqual(usage_details["cache_read_input_tokens"], 3) - + # Test with all fields (all fields are required in TypedDict by default) minimal_usage_details: LangfuseUsageDetails = { "input": 10, @@ -121,10 +119,10 @@ class TestLangfuseUsageDetails(unittest.TestCase): "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0 } - + self.assertEqual(minimal_usage_details["input"], 10) self.assertEqual(minimal_usage_details["output"], 20) - + def test_log_langfuse_v2_usage_details(self): """Test that usage_details in _log_langfuse_v2 is correctly typed and assigned""" # Create a mock response object with usage information @@ -132,7 +130,7 @@ class TestLangfuseUsageDetails(unittest.TestCase): response_obj.usage = MagicMock() response_obj.usage.prompt_tokens = 15 response_obj.usage.completion_tokens = 25 - + # Add the cache token attributes using get method def mock_get(key, default=None): if key == 'cache_creation_input_tokens': @@ -140,20 +138,20 @@ class TestLangfuseUsageDetails(unittest.TestCase): elif key == 'cache_read_input_tokens': return 4 return default - + response_obj.usage.get = mock_get - + # Create kwargs for the log_event method kwargs = { "model": "gpt-4", "messages": [{"role": "user", "content": "Hello"}], "litellm_params": {"metadata": {}} } - + # Create start and end times start_time = datetime.datetime.now() end_time = start_time + datetime.timedelta(seconds=1) - + # Call the log_event method with patch.object(self.logger, '_log_langfuse_v2') as mock_log_langfuse_v2: self.logger.log_event_on_langfuse( @@ -162,16 +160,16 @@ class TestLangfuseUsageDetails(unittest.TestCase): start_time=start_time, end_time=end_time ) - + # Check if _log_langfuse_v2 was called mock_log_langfuse_v2.assert_called_once() - + # Get the arguments passed to _log_langfuse_v2 call_args = mock_log_langfuse_v2.call_args[1] - + # Verify response_obj was passed correctly self.assertEqual(call_args["response_obj"], response_obj) - + def test_langfuse_usage_details_optional_fields(self): """Test that LangfuseUsageDetails fields are properly defined as Optional""" # Create an instance with None values for optional fields @@ -181,18 +179,18 @@ class TestLangfuseUsageDetails(unittest.TestCase): "cache_creation_input_tokens": None, "cache_read_input_tokens": None } - + # Verify fields can be None self.assertEqual(usage_details["input"], 10) self.assertEqual(usage_details["output"], 20) self.assertIsNone(usage_details["cache_creation_input_tokens"]) self.assertIsNone(usage_details["cache_read_input_tokens"]) - + def test_langfuse_usage_details_structure(self): """Test that LangfuseUsageDetails has the correct structure as defined in the commit""" # This test directly verifies the structure of the TypedDict # without relying on the LangFuseLogger class - + # Create a dictionary that matches the LangfuseUsageDetails structure usage_details = { "input": 15, @@ -200,19 +198,15 @@ class TestLangfuseUsageDetails(unittest.TestCase): "cache_creation_input_tokens": 7, "cache_read_input_tokens": 4 } - + # Verify the structure matches what we expect self.assertIn("input", usage_details) self.assertIn("output", usage_details) self.assertIn("cache_creation_input_tokens", usage_details) self.assertIn("cache_read_input_tokens", usage_details) - + # Verify the values self.assertEqual(usage_details["input"], 15) self.assertEqual(usage_details["output"], 25) self.assertEqual(usage_details["cache_creation_input_tokens"], 7) self.assertEqual(usage_details["cache_read_input_tokens"], 4) - - -if __name__ == "__main__": - unittest.main() From 3f9ab84a7d769acb2ba383319726daab873bbb34 Mon Sep 17 00:00:00 2001 From: TomeHirata Date: Tue, 2 Sep 2025 14:36:55 +0900 Subject: [PATCH 08/65] Reapply "Add supported text field to anthropic citation response" --- litellm/llms/anthropic/chat/transformation.py | 10 ++++- .../test_anthropic_completion.py | 18 +++++--- .../test_anthropic_chat_transformation.py | 43 +++++++++++++------ 3 files changed, 53 insertions(+), 18 deletions(-) diff --git a/litellm/llms/anthropic/chat/transformation.py b/litellm/llms/anthropic/chat/transformation.py index ce874bfde9a..378ca75da5f 100644 --- a/litellm/llms/anthropic/chat/transformation.py +++ b/litellm/llms/anthropic/chat/transformation.py @@ -797,7 +797,15 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig): if content.get("citations") is not None: if citations is None: citations = [] - citations.append(content["citations"]) + citations.append( + [ + { + **citation, + "supported_text": content.get("text", ""), + } + for citation in content["citations"] + ] + ) if thinking_blocks is not None: reasoning_content = "" for block in thinking_blocks: diff --git a/tests/llm_translation/test_anthropic_completion.py b/tests/llm_translation/test_anthropic_completion.py index 45702a261e2..f4bd7531b0b 100644 --- a/tests/llm_translation/test_anthropic_completion.py +++ b/tests/llm_translation/test_anthropic_completion.py @@ -920,6 +920,14 @@ def test_anthropic_citations_api(): citations = resp.choices[0].message.provider_specific_fields["citations"] assert citations is not None + if citations: + citation = citations[0][0] + assert "supported_text" in citation + assert "cited_text" in citation + assert "document_index" in citation + assert "document_title" in citation + assert "start_char_index" in citation + assert "end_char_index" in citation def test_anthropic_citations_api_streaming(): @@ -955,11 +963,11 @@ def test_anthropic_citations_api_streaming(): has_citations = False for chunk in resp: print(f"returned chunk: {chunk}") - if ( - chunk.choices[0].delta.provider_specific_fields - and "citation" in chunk.choices[0].delta.provider_specific_fields - ): - has_citations = True + if provider_specific_fields := chunk.choices[0].delta.provider_specific_fields: + if "citation" in provider_specific_fields: + has_citations = True + + assert "chunk_type" in provider_specific_fields assert has_citations diff --git a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py index ff454968d9c..dcca87baf32 100644 --- a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py +++ b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py @@ -115,16 +115,11 @@ def test_calculate_usage_nulls(usage_object, expected_usage): assert hasattr(usage, k) assert getattr(usage, k) == v -@pytest.mark.parametrize("usage_object", [ - { - "server_tool_use": { - "web_search_requests": None - } - }, - { - "server_tool_use": None - } -]) + +@pytest.mark.parametrize( + "usage_object", + [{"server_tool_use": {"web_search_requests": None}}, {"server_tool_use": None}], +) def test_calculate_usage_server_tool_null(usage_object): """ Correctly deal with null values in usage object @@ -132,10 +127,11 @@ def test_calculate_usage_server_tool_null(usage_object): Fixes https://github.com/BerriAI/litellm/issues/11920 """ config = AnthropicConfig() - + usage = config.calculate_usage(usage_object=usage_object, reasoning_content=None) assert not hasattr(usage, "server_tool_use") + def test_extract_response_content_with_citations(): config = AnthropicConfig() @@ -188,7 +184,30 @@ def test_extract_response_content_with_citations(): } _, citations, _, _, _ = config.extract_response_content(completion_response) - assert citations is not None + assert citations == [ + [ + { + "type": "char_location", + "cited_text": "The grass is green. ", + "document_index": 0, + "document_title": "My Document", + "start_char_index": 0, + "end_char_index": 20, + "supported_text": "the grass is green", + }, + ], + [ + { + "type": "char_location", + "cited_text": "The sky is blue.", + "document_index": 0, + "document_title": "My Document", + "start_char_index": 20, + "end_char_index": 36, + "supported_text": "the sky is blue", + }, + ], + ] def test_map_tool_helper(): From 4497dcf762d29396eeda43ac423067eb3d0ec18a Mon Sep 17 00:00:00 2001 From: TomeHirata Date: Tue, 2 Sep 2025 14:39:19 +0900 Subject: [PATCH 09/65] fix test --- tests/llm_translation/test_anthropic_completion.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/llm_translation/test_anthropic_completion.py b/tests/llm_translation/test_anthropic_completion.py index f4bd7531b0b..307c429fc62 100644 --- a/tests/llm_translation/test_anthropic_completion.py +++ b/tests/llm_translation/test_anthropic_completion.py @@ -256,7 +256,6 @@ def test_anthropic_tool_streaming(): for chunk in anthropic_chunk_list: parsed_chunk = response_iter.chunk_parser(chunk) if tool_use := parsed_chunk.get("tool_use"): - # We only increment when a new block starts if tool_use.get("id") is not None: correct_tool_index += 1 @@ -967,8 +966,6 @@ def test_anthropic_citations_api_streaming(): if "citation" in provider_specific_fields: has_citations = True - assert "chunk_type" in provider_specific_fields - assert has_citations From 6d7d5ed07805fe40ec3ebdba2eca6fd769de7cdc Mon Sep 17 00:00:00 2001 From: Fabricio Ceschin Date: Mon, 8 Sep 2025 11:37:24 -0400 Subject: [PATCH 10/65] Updating poetry.lock --- poetry.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/poetry.lock b/poetry.lock index 771bb6d486e..41182d12bff 100644 --- a/poetry.lock +++ b/poetry.lock @@ -9182,4 +9182,4 @@ utils = ["numpydoc"] [metadata] lock-version = "2.1" python-versions = ">=3.8.1,<4.0, !=3.9.7" -content-hash = "8ebdb444c0ff253857f90d3ec9926a58d23d4482c644fd158a047f0c0f892bb9" +content-hash = "54374b906931afe92861b6b9b226751579c0d342f650bc8f7ebaf4c5882d6249" From b8b30775a4c014530047a3e0b3603fd6451eb008 Mon Sep 17 00:00:00 2001 From: Daniel Klein Date: Wed, 17 Sep 2025 11:31:07 -0400 Subject: [PATCH 11/65] fix: update sonnet 4 configs to reflect million-context-window pricing --- ...odel_prices_and_context_window_backup.json | 78 +++++++++++++------ model_prices_and_context_window.json | 78 +++++++++++++------ 2 files changed, 108 insertions(+), 48 deletions(-) diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 5e5bccb81e8..ecb71297690 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -500,10 +500,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -764,10 +768,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -4727,10 +4735,14 @@ "cache_creation_input_token_cost_above_1hr": 6e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "anthropic", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -7487,10 +7499,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -16036,10 +16052,12 @@ "openrouter/anthropic/claude-sonnet-4": { "input_cost_per_image": 0.0048, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, "litellm_provider": "openrouter", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "supports_assistant_prefill": true, @@ -18885,10 +18903,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -20221,10 +20243,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "vertex_ai-anthropic_models", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -20247,10 +20273,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "vertex_ai-anthropic_models", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 5e5bccb81e8..ecb71297690 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -500,10 +500,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -764,10 +768,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -4727,10 +4735,14 @@ "cache_creation_input_token_cost_above_1hr": 6e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "anthropic", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -7487,10 +7499,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -16036,10 +16052,12 @@ "openrouter/anthropic/claude-sonnet-4": { "input_cost_per_image": 0.0048, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, "litellm_provider": "openrouter", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "supports_assistant_prefill": true, @@ -18885,10 +18903,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "bedrock_converse", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -20221,10 +20243,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "vertex_ai-anthropic_models", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { @@ -20247,10 +20273,14 @@ "cache_creation_input_token_cost": 3.75e-06, "cache_read_input_token_cost": 3e-07, "input_cost_per_token": 3e-06, + "input_cost_per_token_above_200k_tokens": 6e-06, + "output_cost_per_token_above_200k_tokens": 2.25e-05, + "cache_creation_input_token_cost_above_200k_tokens": 7.5e-06, + "cache_read_input_token_cost_above_200k_tokens": 6e-07, "litellm_provider": "vertex_ai-anthropic_models", - "max_input_tokens": 200000, - "max_output_tokens": 64000, - "max_tokens": 64000, + "max_input_tokens": 1000000, + "max_output_tokens": 1000000, + "max_tokens": 1000000, "mode": "chat", "output_cost_per_token": 1.5e-05, "search_context_cost_per_query": { From 77a39e7ca9260838112d1822b86da8573c917dd1 Mon Sep 17 00:00:00 2001 From: Dharamendra Kumar Date: Fri, 19 Sep 2025 01:46:53 -0700 Subject: [PATCH 12/65] feat: Add shared_session parameter for aiohttp ClientSession reuse Allow passing aiohttp.ClientSession to acompletion() calls for better performance and resource management. Includes debug logging, tests, and documentation. Backward compatible. --- .../docs/completion/shared_session.md | 213 ++++++++++++++++ litellm/llms/azure/chat/o_series_handler.py | 7 +- litellm/llms/custom_httpx/http_handler.py | 31 ++- litellm/llms/custom_httpx/llm_http_handler.py | 23 +- litellm/llms/openai/common_utils.py | 18 +- litellm/llms/openai/openai.py | 15 +- litellm/main.py | 83 +++++-- .../llms/custom_httpx/test_http_handler.py | 234 +++++++++++++++++- .../test_shared_session_integration.py | 190 ++++++++++++++ 9 files changed, 761 insertions(+), 53 deletions(-) create mode 100644 docs/my-website/docs/completion/shared_session.md create mode 100644 tests/test_litellm/test_shared_session_integration.py diff --git a/docs/my-website/docs/completion/shared_session.md b/docs/my-website/docs/completion/shared_session.md new file mode 100644 index 00000000000..ff3da37f34f --- /dev/null +++ b/docs/my-website/docs/completion/shared_session.md @@ -0,0 +1,213 @@ +# Shared Session Support + +## Overview + +LiteLLM now supports sharing `aiohttp.ClientSession` instances across multiple API calls to avoid creating unnecessary new sessions. This improves performance and resource utilization. + +## Usage + +### Basic Usage + +```python +import asyncio +from aiohttp import ClientSession +from litellm import acompletion + +async def main(): + # Create a shared session + async with ClientSession() as shared_session: + # Use the same session for multiple calls + response1 = await acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "Hello"}], + shared_session=shared_session + ) + + response2 = await acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "How are you?"}], + shared_session=shared_session + ) + + # Both calls reuse the same session! + +asyncio.run(main()) +``` + +### Without Shared Session (Default) + +```python +import asyncio +from litellm import acompletion + +async def main(): + # Each call creates a new session + response1 = await acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "Hello"}] + ) + + response2 = await acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "How are you?"}] + ) + # Two separate sessions created + +asyncio.run(main()) +``` + +## Benefits + +- **Performance**: Reuse HTTP connections across multiple calls +- **Resource Efficiency**: Reduce memory and connection overhead +- **Better Control**: Manage session lifecycle explicitly +- **Debugging**: Easy to trace which calls use which sessions + +## Debug Logging + +Enable debug logging to see session reuse in action: + +```python +import os +import litellm + +# Enable debug logging +os.environ['LITELLM_LOG'] = 'DEBUG' + +# You'll see logs like: +# šŸ”„ SHARED SESSION: acompletion called with shared_session (ID: 12345) +# āœ… SHARED SESSION: Reusing existing ClientSession (ID: 12345) +``` + +## Common Patterns + +### FastAPI Integration + +```python +from fastapi import FastAPI +import aiohttp +import litellm + +app = FastAPI() + +@app.post("/chat") +async def chat(messages: list[dict]): + # Create session per request + async with aiohttp.ClientSession() as session: + return await litellm.acompletion( + model="gpt-4o", + messages=messages, + shared_session=session + ) +``` + +### Batch Processing + +```python +import asyncio +from aiohttp import ClientSession +from litellm import acompletion + +async def process_batch(messages_list): + async with ClientSession() as shared_session: + tasks = [] + for messages in messages_list: + task = acompletion( + model="gpt-4o", + messages=messages, + shared_session=shared_session + ) + tasks.append(task) + + # All tasks use the same session + results = await asyncio.gather(*tasks) + return results +``` + +### Custom Session Configuration + +```python +import aiohttp +import litellm + +# Create optimized session +async with aiohttp.ClientSession( + timeout=aiohttp.ClientTimeout(total=180), + connector=aiohttp.TCPConnector(limit=300, limit_per_host=75) +) as shared_session: + + response = await litellm.acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "Hello"}], + shared_session=shared_session + ) +``` + +## Implementation Details + +The `shared_session` parameter is threaded through the entire LiteLLM call chain: + +1. **`acompletion()`** - Accepts `shared_session` parameter +2. **`BaseLLMHTTPHandler`** - Passes session to HTTP client creation +3. **`AsyncHTTPHandler`** - Uses existing session if provided +4. **`LiteLLMAiohttpTransport`** - Reuses the session for HTTP requests + +## Backward Compatibility + +- **100% backward compatible** - Existing code works unchanged +- **Optional parameter** - `shared_session=None` by default +- **No breaking changes** - All existing functionality preserved + +## Testing + +Test the shared session functionality: + +```python +import asyncio +from aiohttp import ClientSession +from litellm import acompletion + +async def test_shared_session(): + async with ClientSession() as session: + print(f"āœ… Created session: {id(session)}") + + try: + response = await acompletion( + model="gpt-4o", + messages=[{"role": "user", "content": "Hello"}], + shared_session=session, + api_key="your-api-key" + ) + print(f"Response: {response.choices[0].message.content}") + except Exception as e: + print(f"āœ… Expected error: {type(e).__name__}") + + print("āœ… Session control working!") + +asyncio.run(test_shared_session()) +``` + +## Files Modified + +The shared session functionality was added to these files: + +- `litellm/main.py` - Added `shared_session` parameter to `acompletion()` and `completion()` +- `litellm/llms/custom_httpx/http_handler.py` - Core session reuse logic +- `litellm/llms/custom_httpx/llm_http_handler.py` - HTTP handler integration +- `litellm/llms/openai/openai.py` - OpenAI provider integration +- `litellm/llms/openai/common_utils.py` - OpenAI client creation +- `litellm/llms/azure/chat/o_series_handler.py` - Azure O Series handler + +## Troubleshooting + +### Session Not Being Reused + +1. **Check debug logs**: Enable `LITELLM_LOG=DEBUG` to see session reuse messages +2. **Verify session is not closed**: Ensure the session is still active when making calls +3. **Check parameter passing**: Make sure `shared_session` is passed to all `acompletion()` calls + +### Performance Issues + +1. **Session configuration**: Tune `aiohttp.ClientSession` parameters for your use case +2. **Connection limits**: Adjust `limit` and `limit_per_host` in `TCPConnector` +3. **Timeout settings**: Configure appropriate timeouts for your environment diff --git a/litellm/llms/azure/chat/o_series_handler.py b/litellm/llms/azure/chat/o_series_handler.py index 2f3e9e63996..d0f5153b0eb 100644 --- a/litellm/llms/azure/chat/o_series_handler.py +++ b/litellm/llms/azure/chat/o_series_handler.py @@ -4,7 +4,7 @@ Handler file for calls to Azure OpenAI's o1/o3 family of models Written separately to handle faking streaming for o1 and o3 models. """ -from typing import Any, Callable, Optional, Union +from typing import TYPE_CHECKING, Any, Callable, Optional, Union import httpx @@ -13,6 +13,9 @@ from litellm.types.utils import ModelResponse from ...openai.openai import OpenAIChatCompletion from ..common_utils import BaseAzureLLM +if TYPE_CHECKING: + from aiohttp import ClientSession + class AzureOpenAIO1ChatCompletion(BaseAzureLLM, OpenAIChatCompletion): def completion( @@ -38,6 +41,7 @@ class AzureOpenAIO1ChatCompletion(BaseAzureLLM, OpenAIChatCompletion): organization: Optional[str] = None, custom_llm_provider: Optional[str] = None, drop_params: Optional[bool] = None, + shared_session: Optional["ClientSession"] = None, ): client = self.get_azure_openai_client( litellm_params=litellm_params, @@ -69,4 +73,5 @@ class AzureOpenAIO1ChatCompletion(BaseAzureLLM, OpenAIChatCompletion): organization=organization, custom_llm_provider=custom_llm_provider, drop_params=drop_params, + shared_session=shared_session, ) diff --git a/litellm/llms/custom_httpx/http_handler.py b/litellm/llms/custom_httpx/http_handler.py index 36b543086f5..18b0cbd594f 100644 --- a/litellm/llms/custom_httpx/http_handler.py +++ b/litellm/llms/custom_httpx/http_handler.py @@ -167,6 +167,7 @@ class AsyncHTTPHandler: concurrent_limit=1000, client_alias: Optional[str] = None, # name for client in logs ssl_verify: Optional[VerifyTypes] = None, + existing_session: Optional["ClientSession"] = None, ): self.timeout = timeout self.event_hooks = event_hooks @@ -175,6 +176,7 @@ class AsyncHTTPHandler: concurrent_limit=concurrent_limit, event_hooks=event_hooks, ssl_verify=ssl_verify, + existing_session=existing_session, ) self.client_alias = client_alias @@ -184,6 +186,7 @@ class AsyncHTTPHandler: concurrent_limit: int, event_hooks: Optional[Mapping[str, List[Callable[..., Any]]]], ssl_verify: Optional[VerifyTypes] = None, + existing_session: Optional["ClientSession"] = None, ) -> httpx.AsyncClient: # Get unified SSL configuration ssl_config = get_ssl_configuration(ssl_verify) @@ -199,6 +202,7 @@ class AsyncHTTPHandler: transport = AsyncHTTPHandler._create_async_transport( ssl_context=ssl_config if isinstance(ssl_config, ssl.SSLContext) else None, ssl_verify=ssl_config if isinstance(ssl_config, bool) else None, + existing_session=existing_session, ) return httpx.AsyncClient( @@ -260,7 +264,6 @@ class AsyncHTTPHandler: files: Optional[RequestFiles] = None, content: Any = None, ): - start_time = time.time() try: if timeout is None: @@ -523,7 +526,9 @@ class AsyncHTTPHandler: @staticmethod def _create_async_transport( - ssl_context: Optional[ssl.SSLContext] = None, ssl_verify: Optional[bool] = None + ssl_context: Optional[ssl.SSLContext] = None, + ssl_verify: Optional[bool] = None, + existing_session: Optional["ClientSession"] = None, ) -> Optional[Union[LiteLLMAiohttpTransport, AsyncHTTPTransport]]: """ - Creates a transport for httpx.AsyncClient @@ -544,7 +549,9 @@ class AsyncHTTPHandler: ######################################################### if AsyncHTTPHandler._should_use_aiohttp_transport(): return AsyncHTTPHandler._create_aiohttp_transport( - ssl_context=ssl_context, ssl_verify=ssl_verify + ssl_context=ssl_context, + ssl_verify=ssl_verify, + existing_session=existing_session, ) ######################################################### @@ -612,6 +619,7 @@ class AsyncHTTPHandler: def _create_aiohttp_transport( ssl_verify: Optional[bool] = None, ssl_context: Optional[ssl.SSLContext] = None, + existing_session: Optional["ClientSession"] = None, ) -> LiteLLMAiohttpTransport: """ Creates an AiohttpTransport with RequestNotRead error handling @@ -635,6 +643,18 @@ class AsyncHTTPHandler: trust_env = True verbose_logger.debug("Creating AiohttpTransport...") + + # Use existing session if provided and valid + if existing_session is not None and not existing_session.closed: + verbose_logger.debug( + f"SHARED SESSION: Reusing existing ClientSession (ID: {id(existing_session)})" + ) + return LiteLLMAiohttpTransport(client=existing_session) + + # Create new session only if none provided or existing one is invalid + verbose_logger.debug( + "NEW SESSION: Creating new ClientSession (no shared session provided)" + ) return LiteLLMAiohttpTransport( client=lambda: ClientSession( connector=TCPConnector(**connector_kwargs), @@ -921,6 +941,7 @@ class HTTPHandler: def get_async_httpx_client( llm_provider: Union[LlmProviders, httpxSpecialProvider], params: Optional[dict] = None, + existing_session: Optional["ClientSession"] = None, ) -> AsyncHTTPHandler: """ Retrieves the async HTTP client from the cache @@ -942,10 +963,12 @@ def get_async_httpx_client( return _cached_client if params is not None: + params["existing_session"] = existing_session _new_client = AsyncHTTPHandler(**params) else: _new_client = AsyncHTTPHandler( - timeout=httpx.Timeout(timeout=600.0, connect=5.0) + timeout=httpx.Timeout(timeout=600.0, connect=5.0), + existing_session=existing_session, ) litellm.in_memory_llm_clients_cache.set_cache( diff --git a/litellm/llms/custom_httpx/llm_http_handler.py b/litellm/llms/custom_httpx/llm_http_handler.py index dc64fea1a33..74d438db110 100644 --- a/litellm/llms/custom_httpx/llm_http_handler.py +++ b/litellm/llms/custom_httpx/llm_http_handler.py @@ -88,6 +88,7 @@ from litellm.utils import ( ) if TYPE_CHECKING: + from aiohttp import ClientSession from litellm.litellm_core_utils.litellm_logging import Logging as _LiteLLMLoggingObj from litellm.llms.base_llm.passthrough.transformation import BasePassthroughConfig @@ -236,11 +237,16 @@ class BaseLLMHTTPHandler: client: Optional[AsyncHTTPHandler] = None, json_mode: bool = False, signed_json_body: Optional[bytes] = None, + shared_session: Optional["ClientSession"] = None, ): if client is None: + verbose_logger.debug( + f"Creating HTTP client with shared_session: {id(shared_session) if shared_session else None}" + ) async_httpx_client = get_async_httpx_client( llm_provider=litellm.LlmProviders(custom_llm_provider), params={"ssl_verify": litellm_params.get("ssl_verify", None)}, + existing_session=shared_session, ) else: async_httpx_client = client @@ -290,6 +296,7 @@ class BaseLLMHTTPHandler: headers: Optional[Dict[str, Any]] = None, client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, provider_config: Optional[BaseConfig] = None, + shared_session: Optional["ClientSession"] = None, ): json_mode: bool = optional_params.pop("json_mode", False) extra_body: Optional[dict] = optional_params.pop("extra_body", None) @@ -469,7 +476,7 @@ class BaseLLMHTTPHandler: if client is None or not isinstance(client, HTTPHandler): sync_httpx_client = _get_httpx_client( - params={"ssl_verify": litellm_params.get("ssl_verify", None)} + params={"ssl_verify": litellm_params.get("ssl_verify", None)}, ) else: sync_httpx_client = client @@ -2283,7 +2290,7 @@ class BaseLLMHTTPHandler: e=e, provider_config=provider_config, ) - + # Store the upload URL in litellm_params for the transformation method litellm_params_with_url = dict(litellm_params) litellm_params_with_url["upload_url"] = api_base @@ -2574,11 +2581,11 @@ class BaseLLMHTTPHandler: "url": transformed_request["url"], "headers": transformed_request["headers"], } - + # Only add data for non-GET requests if method != "get" and transformed_request.get("data") is not None: request_kwargs["data"] = transformed_request["data"] - + batch_response = getattr(sync_httpx_client, method)(**request_kwargs) elif isinstance(transformed_request, dict) and api_base: # For other providers that use JSON requests @@ -2743,12 +2750,14 @@ class BaseLLMHTTPHandler: "url": transformed_request["url"], "headers": transformed_request["headers"], } - + # Only add data for non-GET requests if method != "get" and transformed_request.get("data") is not None: request_kwargs["data"] = transformed_request["data"] - - batch_response = await getattr(async_httpx_client, method)(**request_kwargs) + + batch_response = await getattr(async_httpx_client, method)( + **request_kwargs + ) elif isinstance(transformed_request, dict) and api_base: # For other providers that use JSON requests batch_response = await async_httpx_client.get( diff --git a/litellm/llms/openai/common_utils.py b/litellm/llms/openai/common_utils.py index aa670df0531..0b2daa1446c 100644 --- a/litellm/llms/openai/common_utils.py +++ b/litellm/llms/openai/common_utils.py @@ -5,12 +5,15 @@ Common helpers / utils across al OpenAI endpoints import hashlib import json import ssl -from typing import Any, Dict, List, Literal, Optional, Union +from typing import Any, Dict, List, Literal, Optional, TYPE_CHECKING, Union import httpx import openai from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI +if TYPE_CHECKING: + from aiohttp import ClientSession + import litellm from litellm.llms.base_llm.chat.transformation import BaseLLMException from litellm.llms.custom_httpx.http_handler import ( @@ -194,7 +197,9 @@ class BaseOpenAILLM: return param_names @staticmethod - def _get_async_http_client() -> Optional[httpx.AsyncClient]: + def _get_async_http_client( + shared_session: Optional["ClientSession"] = None, + ) -> Optional[httpx.AsyncClient]: if litellm.aclient_session is not None: return litellm.aclient_session @@ -205,8 +210,11 @@ class BaseOpenAILLM: limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100), verify=ssl_config, transport=AsyncHTTPHandler._create_async_transport( - ssl_context=ssl_config if isinstance(ssl_config, ssl.SSLContext) else None, + ssl_context=ssl_config + if isinstance(ssl_config, ssl.SSLContext) + else None, ssl_verify=ssl_config if isinstance(ssl_config, bool) else None, + existing_session=shared_session, ), follow_redirects=True, ) @@ -215,10 +223,10 @@ class BaseOpenAILLM: def _get_sync_http_client() -> Optional[httpx.Client]: if litellm.client_session is not None: return litellm.client_session - + # Get unified SSL configuration ssl_config = get_ssl_configuration() - + return httpx.Client( limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100), verify=ssl_config, diff --git a/litellm/llms/openai/openai.py b/litellm/llms/openai/openai.py index 1f3cf24457d..3347e533242 100644 --- a/litellm/llms/openai/openai.py +++ b/litellm/llms/openai/openai.py @@ -10,12 +10,16 @@ from typing import ( List, Literal, Optional, + TYPE_CHECKING, Union, cast, ) from urllib.parse import urlparse import httpx + +if TYPE_CHECKING: + from aiohttp import ClientSession import openai from openai import AsyncOpenAI, OpenAI from openai.types.beta.assistant_deleted import AssistantDeleted @@ -355,6 +359,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): max_retries: Optional[int] = DEFAULT_MAX_RETRIES, organization: Optional[str] = None, client: Optional[Union[OpenAI, AsyncOpenAI]] = None, + shared_session: Optional["ClientSession"] = None, ) -> Optional[Union[OpenAI, AsyncOpenAI]]: client_initialization_params: Dict = locals() if client is None: @@ -379,7 +384,9 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): _new_client: Union[OpenAI, AsyncOpenAI] = AsyncOpenAI( api_key=api_key, base_url=api_base, - http_client=OpenAIChatCompletion._get_async_http_client(), + http_client=OpenAIChatCompletion._get_async_http_client( + shared_session=shared_session + ), timeout=timeout, max_retries=max_retries, organization=organization, @@ -522,8 +529,9 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): organization: Optional[str] = None, custom_llm_provider: Optional[str] = None, drop_params: Optional[bool] = None, + shared_session: Optional["ClientSession"] = None, ): - super().completion() + super().completion(shared_session=shared_session) try: fake_stream: bool = False inference_params = optional_params.copy() @@ -606,6 +614,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): organization=organization, drop_params=drop_params, fake_stream=fake_stream, + shared_session=shared_session, ) data = provider_config.transform_request( @@ -771,6 +780,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): drop_params: Optional[bool] = None, stream_options: Optional[dict] = None, fake_stream: bool = False, + shared_session: Optional["ClientSession"] = None, ): response = None data = await provider_config.async_transform_request( @@ -793,6 +803,7 @@ class OpenAIChatCompletion(BaseLLM, BaseOpenAILLM): max_retries=max_retries, organization=organization, client=client, + shared_session=shared_session, ) ## LOGGING diff --git a/litellm/main.py b/litellm/main.py index 44f591d49ae..6b2e13b8798 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -36,8 +36,12 @@ from typing import ( Union, cast, get_args, + TYPE_CHECKING, ) +if TYPE_CHECKING: + from aiohttp import ClientSession + import dotenv import httpx import openai @@ -374,6 +378,8 @@ async def acompletion( # Optional liteLLM function params thinking: Optional[AnthropicThinkingParam] = None, web_search_options: Optional[OpenAIWebSearchOptions] = None, + # Session management + shared_session: Optional["ClientSession"] = None, **kwargs, ) -> Union[ModelResponse, CustomStreamWrapper]: """ @@ -466,6 +472,16 @@ async def acompletion( ######################################################### ######################################################### + # Log shared session usage + if shared_session is not None: + verbose_logger.debug( + f"šŸ”„ SHARED SESSION: acompletion called with shared_session (ID: {id(shared_session)})" + ) + else: + verbose_logger.debug( + "šŸ”„ NO SHARED SESSION: acompletion called without shared_session" + ) + # Adjusted to use explicit arguments instead of *args and **kwargs completion_kwargs = { "model": model, @@ -506,6 +522,7 @@ async def acompletion( "acompletion": True, # assuming this is a required parameter "thinking": thinking, "web_search_options": web_search_options, + "shared_session": shared_session, } if custom_llm_provider is None: _, custom_llm_provider, _, _ = get_llm_provider( @@ -930,6 +947,8 @@ def completion( # type: ignore # noqa: PLR0915 model_list: Optional[list] = None, # pass in a list of api_base,keys, etc. # Optional liteLLM function params thinking: Optional[AnthropicThinkingParam] = None, + # Session management + shared_session: Optional["ClientSession"] = None, **kwargs, ) -> Union[ModelResponse, CustomStreamWrapper]: """ @@ -1075,7 +1094,6 @@ def completion( # type: ignore # noqa: PLR0915 prompt_id=prompt_id, non_default_params=non_default_params ) ): - ( model, messages, @@ -1596,6 +1614,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, # type: ignore client=client, custom_llm_provider=custom_llm_provider, @@ -1642,6 +1661,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, # type: ignore client=client, # pass AsyncOpenAI, OpenAI client custom_llm_provider=custom_llm_provider, @@ -1771,6 +1791,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, # type: ignore client=client, custom_llm_provider=custom_llm_provider, @@ -1800,6 +1821,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, client=client, custom_llm_provider=custom_llm_provider, @@ -1830,6 +1852,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, # type: ignore client=client, custom_llm_provider=custom_llm_provider, @@ -1881,6 +1904,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider=custom_llm_provider, timeout=timeout, headers=headers, @@ -1954,6 +1978,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, client=client, custom_llm_provider=custom_llm_provider, @@ -2032,7 +2057,6 @@ def completion( # type: ignore # noqa: PLR0915 try: if use_base_llm_http_handler: - response = base_llm_http_handler.completion( model=model, messages=messages, @@ -2044,6 +2068,7 @@ def completion( # type: ignore # noqa: PLR0915 optional_params=optional_params, timeout=timeout, litellm_params=litellm_params, + shared_session=shared_session, acompletion=acompletion, stream=stream, api_key=api_key, @@ -2070,6 +2095,7 @@ def completion( # type: ignore # noqa: PLR0915 client=client, # pass AsyncOpenAI, OpenAI client organization=organization, custom_llm_provider=custom_llm_provider, + shared_session=shared_session, ) except Exception as e: ## LOGGING - log the original exception returned @@ -2110,6 +2136,7 @@ def completion( # type: ignore # noqa: PLR0915 optional_params=optional_params, timeout=timeout, litellm_params=litellm_params, + shared_session=shared_session, acompletion=acompletion, stream=stream, api_key=api_key, @@ -2197,6 +2224,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="clarifai", timeout=timeout, headers=headers, @@ -2242,6 +2270,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="anthropic_text", timeout=timeout, headers=headers, @@ -2427,6 +2456,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="cohere_chat", timeout=timeout, headers=headers, @@ -2512,15 +2542,10 @@ def completion( # type: ignore # noqa: PLR0915 ) elif custom_llm_provider == "compactifai": api_key = ( - api_key - or get_secret_str("COMPACTIFAI_API_KEY") - or litellm.api_key + api_key or get_secret_str("COMPACTIFAI_API_KEY") or litellm.api_key ) - api_base = ( - api_base - or "https://api.compactif.ai/v1" - ) + api_base = api_base or "https://api.compactif.ai/v1" ## COMPLETION CALL response = base_llm_http_handler.completion( @@ -2694,6 +2719,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="openrouter", timeout=timeout, headers=headers, @@ -2756,6 +2782,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="vercel_ai_gateway", timeout=timeout, headers=headers, @@ -3106,9 +3133,9 @@ def completion( # type: ignore # noqa: PLR0915 "aws_region_name" not in optional_params or optional_params["aws_region_name"] is None ): - optional_params["aws_region_name"] = ( - aws_bedrock_client.meta.region_name - ) + optional_params[ + "aws_region_name" + ] = aws_bedrock_client.meta.region_name bedrock_route = BedrockModelInfo.get_bedrock_route(model) if bedrock_route == "converse": @@ -3242,6 +3269,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="watsonx_text", timeout=timeout, headers=headers, @@ -3295,6 +3323,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="ollama", timeout=timeout, headers=headers, @@ -3328,6 +3357,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="ollama_chat", timeout=timeout, headers=headers, @@ -3348,6 +3378,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider=custom_llm_provider, timeout=timeout, headers=headers, @@ -3380,6 +3411,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="cloudflare", timeout=timeout, headers=headers, @@ -3433,6 +3465,7 @@ def completion( # type: ignore # noqa: PLR0915 logging_obj=logging, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, timeout=timeout, # type: ignore client=client, custom_llm_provider=custom_llm_provider, @@ -3450,7 +3483,6 @@ def completion( # type: ignore # noqa: PLR0915 ) raise e elif custom_llm_provider == "gradient_ai": - api_base = litellm.api_base or api_base response = base_llm_http_handler.completion( model=model, @@ -3461,6 +3493,7 @@ def completion( # type: ignore # noqa: PLR0915 model_response=model_response, optional_params=optional_params, litellm_params=litellm_params, + shared_session=shared_session, custom_llm_provider="gradient_ai", timeout=timeout, headers=headers, @@ -5089,9 +5122,9 @@ def adapter_completion( new_kwargs = translation_obj.translate_completion_input_params(kwargs=kwargs) response: Union[ModelResponse, CustomStreamWrapper] = completion(**new_kwargs) # type: ignore - translated_response: Optional[Union[BaseModel, AdapterCompletionStreamWrapper]] = ( - None - ) + translated_response: Optional[ + Union[BaseModel, AdapterCompletionStreamWrapper] + ] = None if isinstance(response, ModelResponse): translated_response = translation_obj.translate_completion_output_params( response=response @@ -6079,9 +6112,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(content_chunks) > 0: - response["choices"][0]["message"]["content"] = ( - processor.get_combined_content(content_chunks) - ) + response["choices"][0]["message"][ + "content" + ] = processor.get_combined_content(content_chunks) thinking_blocks = [ chunk @@ -6092,9 +6125,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(thinking_blocks) > 0: - response["choices"][0]["message"]["thinking_blocks"] = ( - processor.get_combined_thinking_content(thinking_blocks) - ) + response["choices"][0]["message"][ + "thinking_blocks" + ] = processor.get_combined_thinking_content(thinking_blocks) reasoning_chunks = [ chunk @@ -6105,9 +6138,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(reasoning_chunks) > 0: - response["choices"][0]["message"]["reasoning_content"] = ( - processor.get_combined_reasoning_content(reasoning_chunks) - ) + response["choices"][0]["message"][ + "reasoning_content" + ] = processor.get_combined_reasoning_content(reasoning_chunks) audio_chunks = [ chunk diff --git a/tests/test_litellm/llms/custom_httpx/test_http_handler.py b/tests/test_litellm/llms/custom_httpx/test_http_handler.py index a649e9b6b9c..d33a3d0918b 100644 --- a/tests/test_litellm/llms/custom_httpx/test_http_handler.py +++ b/tests/test_litellm/llms/custom_httpx/test_http_handler.py @@ -29,16 +29,17 @@ async def test_ssl_security_level(monkeypatch): # Get the transport (should be LiteLLMAiohttpTransport) transport = client.client._transport + assert isinstance(transport, LiteLLMAiohttpTransport) # Get the aiohttp ClientSession client_session = transport._get_valid_client_session() # Get the connector from the session connector = client_session.connector + assert isinstance(connector, TCPConnector) # Get the SSL context from the connector ssl_context = connector._ssl - print("ssl_context", ssl_context) # Verify that the SSL context exists and has the correct cipher string assert isinstance(ssl_context, ssl.SSLContext) @@ -108,20 +109,19 @@ async def test_ssl_verification_with_aiohttp_transport(): # Create a test SSL context litellm_async_client = AsyncHTTPHandler(ssl_verify=False) - transport_connector = ( - litellm_async_client.client._transport._get_valid_client_session().connector - ) - print("transport_connector", transport_connector) - print("transport_connector._ssl", transport_connector._ssl) + transport = litellm_async_client.client._transport + assert isinstance(transport, LiteLLMAiohttpTransport) + transport_connector = transport._get_valid_client_session().connector + assert isinstance(transport_connector, TCPConnector) aiohttp_session = aiohttp.ClientSession( connector=aiohttp.TCPConnector(verify_ssl=False) ) - print("aiohttp_session", aiohttp_session) - print("aiohttp_session._ssl", aiohttp_session.connector._ssl) + aiohttp_connector = aiohttp_session.connector + assert isinstance(aiohttp_connector, aiohttp.TCPConnector) # assert both litellm transport and aiohttp session have ssl_verify=False - assert transport_connector._ssl == aiohttp_session.connector._ssl + assert transport_connector._ssl == aiohttp_connector._ssl @pytest.mark.asyncio @@ -183,3 +183,219 @@ def test_get_ssl_configuration_integration(): # Verify it has basic SSL context properties assert ssl_context.protocol is not None assert ssl_context.verify_mode is not None + + +# Session Reuse Tests +class MockClientSession: + """Mock ClientSession that is not callable""" + def __init__(self): + self.closed = False + +@pytest.mark.asyncio +async def test_create_aiohttp_transport_with_existing_session(): + """Test that _create_aiohttp_transport reuses existing session when provided""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Create a mock existing session that's not callable + mock_session = MockClientSession() + + # Test with existing session + transport = AsyncHTTPHandler._create_aiohttp_transport( + existing_session=mock_session # type: ignore + ) + + # Verify the transport uses the existing session directly + assert transport.client is mock_session + assert not callable(transport.client) # Should not be callable + + +@pytest.mark.asyncio +async def test_create_aiohttp_transport_without_existing_session(): + """Test that _create_aiohttp_transport creates new session when none provided""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Test without existing session + transport = AsyncHTTPHandler._create_aiohttp_transport(existing_session=None) + + # Verify the transport uses a lambda function (for backward compatibility) + assert callable(transport.client) # Should be a lambda function + + +@pytest.mark.asyncio +async def test_create_aiohttp_transport_with_closed_session(): + """Test that _create_aiohttp_transport creates new session when existing session is closed""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Create a mock closed session + mock_session = MockClientSession() + mock_session.closed = True + + # Test with closed session + transport = AsyncHTTPHandler._create_aiohttp_transport( + existing_session=mock_session # type: ignore + ) + + # Verify the transport creates a new session (lambda function) + assert callable(transport.client) # Should be a lambda function + + +@pytest.mark.asyncio +async def test_async_handler_with_existing_session(): + """Test AsyncHTTPHandler initialization with existing session""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Create a mock existing session + mock_session = MockClientSession() + + # Create handler with existing session + handler = AsyncHTTPHandler(existing_session=mock_session) # type: ignore + + # Verify the handler was created successfully + assert handler is not None + assert handler.client is not None + + +@pytest.mark.asyncio +async def test_get_async_httpx_client_with_existing_session(): + """Test get_async_httpx_client with existing session""" + from litellm.llms.custom_httpx.http_handler import get_async_httpx_client + from litellm.types.utils import LlmProviders + + # Create a mock existing session + mock_session = MockClientSession() + + # Test with existing session + client = get_async_httpx_client( + llm_provider=LlmProviders.ANTHROPIC, + existing_session=mock_session # type: ignore + ) + + # Verify the client was created successfully + assert client is not None + assert isinstance(client, AsyncHTTPHandler) + + +@pytest.mark.asyncio +async def test_get_async_httpx_client_without_existing_session(): + """Test get_async_httpx_client without existing session (backward compatibility)""" + from litellm.llms.custom_httpx.http_handler import get_async_httpx_client + from litellm.types.utils import LlmProviders + + # Test without existing session + client = get_async_httpx_client( + llm_provider=LlmProviders.ANTHROPIC, + existing_session=None + ) + + # Verify the client was created successfully + assert client is not None + assert isinstance(client, AsyncHTTPHandler) + + +@pytest.mark.asyncio +async def test_session_reuse_chain(): + """Test that session is properly passed through the entire call chain""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Create a mock existing session + mock_session = MockClientSession() + + # Test the entire chain + transport = AsyncHTTPHandler._create_async_transport( + existing_session=mock_session # type: ignore + ) + + # Verify the transport was created + assert transport is not None + + # Test AsyncHTTPHandler creation + handler = AsyncHTTPHandler(existing_session=mock_session) # type: ignore + assert handler is not None + + +def test_shared_session_parameter_in_acompletion(): + """Test that acompletion function accepts shared_session parameter""" + import inspect + from litellm.main import acompletion + + # Get the function signature + sig = inspect.signature(acompletion) + params = list(sig.parameters.keys()) + + # Verify shared_session parameter exists + assert 'shared_session' in params + + # Verify the parameter type annotation + shared_session_param = sig.parameters['shared_session'] + assert 'ClientSession' in str(shared_session_param.annotation) + + +def test_shared_session_parameter_in_completion(): + """Test that completion function accepts shared_session parameter""" + import inspect + from litellm.main import completion + + # Get the function signature + sig = inspect.signature(completion) + params = list(sig.parameters.keys()) + + # Verify shared_session parameter exists + assert 'shared_session' in params + + # Verify the parameter type annotation + shared_session_param = sig.parameters['shared_session'] + assert 'ClientSession' in str(shared_session_param.annotation) + + +@pytest.mark.asyncio +async def test_session_reuse_integration(): + """Integration test for session reuse functionality""" + from litellm.llms.custom_httpx.http_handler import get_async_httpx_client + from litellm.types.utils import LlmProviders + + # Create a mock session + mock_session = MockClientSession() + + # Create two clients with the same session + client1 = get_async_httpx_client( + llm_provider=LlmProviders.ANTHROPIC, + existing_session=mock_session # type: ignore + ) + + client2 = get_async_httpx_client( + llm_provider=LlmProviders.OPENAI, + existing_session=mock_session # type: ignore + ) + + # Both clients should be created successfully + assert client1 is not None + assert client2 is not None + + # Both should be AsyncHTTPHandler instances + assert isinstance(client1, AsyncHTTPHandler) + assert isinstance(client2, AsyncHTTPHandler) + + # Clean up + await client1.close() + await client2.close() + + +@pytest.mark.asyncio +async def test_session_validation(): + """Test that session validation works correctly""" + from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + + # Test with None session + transport1 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=None) + assert callable(transport1.client) # Should create lambda + + # Test with closed session + mock_closed_session = MockClientSession() + mock_closed_session.closed = True + transport2 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=mock_closed_session) # type: ignore + assert callable(transport2.client) # Should create lambda + + # Test with valid session + mock_valid_session = MockClientSession() + transport3 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=mock_valid_session) # type: ignore + assert transport3.client is mock_valid_session # Should reuse session diff --git a/tests/test_litellm/test_shared_session_integration.py b/tests/test_litellm/test_shared_session_integration.py new file mode 100644 index 00000000000..94ec12b4e56 --- /dev/null +++ b/tests/test_litellm/test_shared_session_integration.py @@ -0,0 +1,190 @@ +""" +Integration tests for shared session functionality in main.py +""" +import os +import sys +from unittest.mock import MagicMock, patch + +import pytest + +# Add the litellm directory to the path +sys.path.insert(0, os.path.abspath("../../..")) + +import litellm + + +class TestSharedSessionIntegration: + """Test cases for shared session integration in main.py""" + + def test_acompletion_shared_session_parameter(self): + """Test that acompletion accepts shared_session parameter""" + import inspect + + # Get the function signature + sig = inspect.signature(litellm.acompletion) + params = list(sig.parameters.keys()) + + # Verify shared_session parameter exists + assert 'shared_session' in params + + # Verify the parameter type annotation + shared_session_param = sig.parameters['shared_session'] + assert 'ClientSession' in str(shared_session_param.annotation) + + # Verify default value is None + assert shared_session_param.default is None + + def test_completion_shared_session_parameter(self): + """Test that completion accepts shared_session parameter""" + import inspect + + # Get the function signature + sig = inspect.signature(litellm.completion) + params = list(sig.parameters.keys()) + + # Verify shared_session parameter exists + assert 'shared_session' in params + + # Verify the parameter type annotation + shared_session_param = sig.parameters['shared_session'] + assert 'ClientSession' in str(shared_session_param.annotation) + + # Verify default value is None + assert shared_session_param.default is None + + @pytest.mark.asyncio + async def test_acompletion_with_shared_session_mock(self): + """Test acompletion with mocked shared session (no actual API call)""" + import inspect + + # Create a mock session + mock_session = MagicMock() + mock_session.closed = False + + # Mock the completion function to avoid actual API calls + with patch('litellm.completion') as mock_completion: + mock_completion.return_value = {"choices": [{"message": {"content": "test"}}]} + + # This should not raise an error even though we can't make actual API calls + try: + # We can't actually call acompletion without proper setup, + # but we can verify the parameter is accepted + sig = inspect.signature(litellm.acompletion) + assert 'shared_session' in sig.parameters + except Exception as e: + # Expected to fail due to missing API keys, but parameter should be valid + sig = inspect.signature(litellm.acompletion) + assert 'shared_session' in sig.parameters + + def test_shared_session_passed_to_completion_kwargs(self): + """Test that shared_session is passed through completion_kwargs""" + # This test verifies that the shared_session parameter + # is properly included in the completion_kwargs dictionary + + # We can't easily test the internal logic without mocking, + # but we can verify the parameter exists in the function signature + import inspect + + sig = inspect.signature(litellm.acompletion) + shared_session_param = sig.parameters['shared_session'] + + # Verify the parameter is properly typed + assert 'ClientSession' in str(shared_session_param.annotation) + assert shared_session_param.default is None + + def test_backward_compatibility(self): + """Test that existing code without shared_session still works""" + import inspect + + # Verify that shared_session has a default value of None + sig = inspect.signature(litellm.acompletion) + shared_session_param = sig.parameters['shared_session'] + + # This ensures backward compatibility + assert shared_session_param.default is None + + def test_type_annotations_consistency(self): + """Test that type annotations are consistent between acompletion and completion""" + import inspect + + # Get signatures for both functions + acompletion_sig = inspect.signature(litellm.acompletion) + completion_sig = inspect.signature(litellm.completion) + + # Get the shared_session parameters + acompletion_param = acompletion_sig.parameters['shared_session'] + completion_param = completion_sig.parameters['shared_session'] + + # Verify they have the same type annotation + assert str(acompletion_param.annotation) == str(completion_param.annotation) + + # Verify they have the same default value + assert acompletion_param.default == completion_param.default + + def test_shared_session_parameter_position(self): + """Test that shared_session parameter is in the correct position""" + import inspect + + sig = inspect.signature(litellm.acompletion) + params = list(sig.parameters.keys()) + + # Find the position of shared_session + shared_session_index = params.index('shared_session') + + # It should be near the end, before **kwargs + assert shared_session_index > 0 + assert shared_session_index < len(params) - 1 # Should be before **kwargs + + # Verify it's after the main parameters + assert 'model' in params[:shared_session_index] + assert 'messages' in params[:shared_session_index] + + +class TestSharedSessionUsage: + """Test cases demonstrating proper usage of shared sessions""" + + def test_shared_session_usage_example(self): + """Test example usage pattern for shared sessions""" + # This test demonstrates the expected usage pattern + # without actually making API calls + + import inspect + + # Verify the function signature allows for the expected usage + sig = inspect.signature(litellm.acompletion) + params = sig.parameters + + # Verify all expected parameters exist + expected_params = [ + 'model', 'messages', 'shared_session' + ] + + for param in expected_params: + assert param in params, f"Parameter {param} not found in acompletion signature" + + # Verify shared_session is optional + assert params['shared_session'].default is None + + def test_shared_session_with_other_parameters(self): + """Test that shared_session works with other parameters""" + import inspect + + sig = inspect.signature(litellm.acompletion) + params = sig.parameters + + # Verify shared_session doesn't conflict with other parameters + assert 'shared_session' in params + assert 'model' in params + assert 'messages' in params + assert 'timeout' in params + + # Verify the parameter order makes sense + param_list = list(params.keys()) + shared_session_index = param_list.index('shared_session') + + # shared_session should be after the main parameters but before **kwargs + assert shared_session_index > param_list.index('model') + assert shared_session_index > param_list.index('messages') + + # Should be before **kwargs (last parameter) + assert shared_session_index < len(param_list) - 1 From 6a9ebe88c2a6ce67c4c819975da74af387001526 Mon Sep 17 00:00:00 2001 From: Roman Leventov Date: Tue, 23 Sep 2025 13:50:10 +0800 Subject: [PATCH 13/65] Don't submit a task to a thread if streaming logging is disabled --- litellm/litellm_core_utils/streaming_handler.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/litellm/litellm_core_utils/streaming_handler.py b/litellm/litellm_core_utils/streaming_handler.py index 322691e28b4..bc0fbdf5c11 100644 --- a/litellm/litellm_core_utils/streaming_handler.py +++ b/litellm/litellm_core_utils/streaming_handler.py @@ -1619,11 +1619,12 @@ class CustomStreamWrapper: completion_start_time=datetime.datetime.now() ) ## LOGGING - executor.submit( - self.run_success_logging_and_cache_storage, - response, - cache_hit, - ) # log response + if not litellm.disable_streaming_logging: + executor.submit( + self.run_success_logging_and_cache_storage, + response, + cache_hit, + ) # log response choice = response.choices[0] if isinstance(choice, StreamingChoices): self.response_uptil_now += choice.delta.get("content", "") or "" From 0a5fe102a28f70a4b06a452f1843c5ca605f89d2 Mon Sep 17 00:00:00 2001 From: Roman Leventov Date: Tue, 23 Sep 2025 15:01:42 +0800 Subject: [PATCH 14/65] Make httpx's sync transport configurable --- litellm/llms/custom_httpx/http_handler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/llms/custom_httpx/http_handler.py b/litellm/llms/custom_httpx/http_handler.py index 36b543086f5..28b1470e1f2 100644 --- a/litellm/llms/custom_httpx/http_handler.py +++ b/litellm/llms/custom_httpx/http_handler.py @@ -915,7 +915,7 @@ class HTTPHandler: if litellm.force_ipv4: return HTTPTransport(local_address="0.0.0.0") else: - return None + return getattr(litellm, 'sync_transport', None) def get_async_httpx_client( From b4512cb1e753699927ef8d1a5bed5d1ab59a8d88 Mon Sep 17 00:00:00 2001 From: eycjur Date: Tue, 23 Sep 2025 12:33:39 +0000 Subject: [PATCH 15/65] Fix load credentials in token counter proxy --- litellm/proxy/proxy_server.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 52f42c9f310..472aeb140cf 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -35,6 +35,7 @@ from litellm.constants import ( LITELLM_SETTINGS_SAFE_DB_OVERRIDES, ) from litellm.litellm_core_utils.safe_json_dumps import safe_dumps +from litellm.utils import load_credentials_from_list from litellm.types.utils import ( ModelResponse, ModelResponseStream, @@ -5894,6 +5895,7 @@ async def token_counter(request: TokenCountRequest, call_endpoint: bool = False) pass if deployment is not None: litellm_model_name = deployment.get("litellm_params", {}).get("model") + load_credentials_from_list(deployment.get("litellm_params", {})) # remove the custom_llm_provider_prefix in the litellm_model_name if "/" in litellm_model_name: litellm_model_name = litellm_model_name.split("/", 1)[1] From c51e0fc54e6f5fd6aa1b1ee61f04a23762a3f764 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Tue, 23 Sep 2025 23:55:14 +0900 Subject: [PATCH 16/65] fastuuid optional dependency --- litellm/_uuid.py | 23 +++++++++++++++++++ litellm/litellm_core_utils/litellm_logging.py | 2 +- litellm/llms/bedrock/common_utils.py | 2 +- litellm/proxy/common_request_processing.py | 2 +- litellm/types/utils.py | 2 +- litellm/utils.py | 2 +- poetry.lock | 12 ++++++---- pyproject.toml | 4 +++- requirements.txt | 5 ++-- tests/test_uuid_fallback.py | 11 +++++++++ 10 files changed, 52 insertions(+), 13 deletions(-) create mode 100644 litellm/_uuid.py create mode 100644 tests/test_uuid_fallback.py diff --git a/litellm/_uuid.py b/litellm/_uuid.py new file mode 100644 index 00000000000..05b1adbf75b --- /dev/null +++ b/litellm/_uuid.py @@ -0,0 +1,23 @@ +""" +Internal unified UUID helper. + +Tries to use fastuuid (performance) and falls back to stdlib uuid if unavailable. +""" + +FASTUUID_AVAILABLE = False + +try: + import fastuuid as _uuid # type: ignore + + FASTUUID_AVAILABLE = True +except Exception: # pragma: no cover - fallback path + import uuid as _uuid # type: ignore + + +# Expose a module-like alias so callers can use: uuid.uuid4() +uuid = _uuid + + +def uuid4(): + """Return a UUID4 using the selected backend.""" + return uuid.uuid4() diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py index 059fd9f1fcf..9d67ec1a867 100644 --- a/litellm/litellm_core_utils/litellm_logging.py +++ b/litellm/litellm_core_utils/litellm_logging.py @@ -26,7 +26,7 @@ from typing import ( cast, ) -import fastuuid as uuid +from .._uuid import uuid from httpx import Response from pydantic import BaseModel diff --git a/litellm/llms/bedrock/common_utils.py b/litellm/llms/bedrock/common_utils.py index c7f7acf331d..edfbca8fce6 100644 --- a/litellm/llms/bedrock/common_utils.py +++ b/litellm/llms/bedrock/common_utils.py @@ -774,7 +774,7 @@ class CommonBatchFilesUtils: Returns: Unique job name (ā‰¤ 63 characters for Bedrock compatibility) """ - import fastuuid as uuid + from ..._uuid import uuid unique_id = str(uuid.uuid4())[:8] # Format: {prefix}-batch-{model}-{uuid} # Example: litellm-batch-claude-266c398e diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py index 5739e652043..3807559b35d 100644 --- a/litellm/proxy/common_request_processing.py +++ b/litellm/proxy/common_request_processing.py @@ -14,7 +14,7 @@ from typing import ( Union, ) -import fastuuid as uuid +from .._uuid import uuid import httpx import orjson from fastapi import HTTPException, Request, status diff --git a/litellm/types/utils.py b/litellm/types/utils.py index 25f353b3bc3..e89a98fb2e0 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -13,7 +13,7 @@ from typing import ( Union, ) -import fastuuid as uuid +from .._uuid import uuid from aiohttp import FormData from openai._models import BaseModel as OpenAIObject from openai.types.audio.transcription_create_params import FileTypes # type: ignore diff --git a/litellm/utils.py b/litellm/utils.py index e4cbaec7065..6edb44e48d6 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -40,7 +40,7 @@ from os.path import abspath, dirname, join import aiohttp import dotenv -import fastuuid as uuid +from ._uuid import uuid import httpx import openai import tiktoken diff --git a/poetry.lock b/poetry.lock index 4d0e3bea696..4eb9cae6082 100644 --- a/poetry.lock +++ b/poetry.lock @@ -555,7 +555,7 @@ description = "Foreign Function Interface for Python calling C code." optional = false python-versions = ">=3.8" groups = ["main", "dev", "proxy-dev"] -markers = "python_version < \"3.14\" and platform_python_implementation != \"PyPy\"" +markers = "python_version < \"3.10\" and platform_python_implementation != \"PyPy\"" files = [ {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, @@ -636,7 +636,7 @@ description = "Foreign Function Interface for Python calling C code." optional = false python-versions = ">=3.9" groups = ["main", "dev", "proxy-dev"] -markers = "platform_python_implementation != \"PyPy\" and python_version >= \"3.14\"" +markers = "python_version >= \"3.10\" and platform_python_implementation != \"PyPy\"" files = [ {file = "cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44"}, {file = "cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49"}, @@ -1339,9 +1339,10 @@ zstandard = ["zstandard"] name = "fastuuid" version = "0.12.0" description = "Python bindings to Rust's UUID library." -optional = false +optional = true python-versions = ">=3.8" groups = ["main"] +markers = "extra == \"perf\"" files = [ {file = "fastuuid-0.12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:22a900ef0956aacf862b460e20541fdae2d7c340594fe1bd6fdcb10d5f0791a9"}, {file = "fastuuid-0.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0302f5acf54dc75de30103025c5a95db06d6c2be36829043a0aa16fc170076bc"}, @@ -4361,7 +4362,7 @@ description = "C parser in Python" optional = false python-versions = ">=3.8" groups = ["main", "dev", "proxy-dev"] -markers = "platform_python_implementation != \"PyPy\" and (python_version < \"3.14\" or implementation_name != \"PyPy\")" +markers = "platform_python_implementation != \"PyPy\" and (implementation_name != \"PyPy\" or python_version < \"3.10\")" files = [ {file = "pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934"}, {file = "pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2"}, @@ -6746,6 +6747,7 @@ type = ["pytest-mypy"] caching = ["diskcache"] extra-proxy = ["azure-identity", "azure-keyvault-secrets", "google-cloud-iam", "google-cloud-kms", "prisma", "redisvl", "resend"] mlflow = ["mlflow"] +perf = ["fastuuid"] proxy = ["PyJWT", "apscheduler", "azure-identity", "azure-storage-blob", "backoff", "boto3", "cryptography", "fastapi", "fastapi-sso", "gunicorn", "litellm-enterprise", "litellm-proxy-extras", "mcp", "orjson", "polars", "pynacl", "python-multipart", "pyyaml", "rich", "rq", "uvicorn", "uvloop", "websockets"] semantic-router = ["semantic-router"] utils = ["numpydoc"] @@ -6753,4 +6755,4 @@ utils = ["numpydoc"] [metadata] lock-version = "2.1" python-versions = ">=3.8.1,<4.0, !=3.9.7" -content-hash = "dcec654bc4b233d2f0d160341d8adf1ba2017ccb74c104bff9ba4cf027ba0186" +content-hash = "608a9e7680b4109b938a642007a80cc8e8fa57142b614a17b9e9723c8380b2cd" diff --git a/pyproject.toml b/pyproject.toml index 81104d072ee..471e1d17387 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,7 +20,6 @@ Documentation = "https://docs.litellm.ai" [tool.poetry.dependencies] python = ">=3.8.1,<4.0, !=3.9.7" -fastuuid = ">=0.12.0" httpx = ">=0.23.0" openai = ">=1.99.5" python-dotenv = ">=0.2.0" @@ -34,6 +33,7 @@ pydantic = "^2.5.0" jsonschema = "^4.22.0" pondpond = "^1.4.1" numpydoc = {version = "*", optional = true} # used in utils.py +fastuuid = {version = ">=0.12.0", optional = true} uvicorn = {version = "^0.29.0", optional = true} uvloop = {version = "^0.21.0", optional = true, markers="sys_platform != 'win32'"} @@ -115,6 +115,8 @@ semantic-router = ["semantic-router"] mlflow = ["mlflow"] +perf = ["fastuuid"] + [tool.isort] profile = "black" diff --git a/requirements.txt b/requirements.txt index 41f4c646958..a276da2da72 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,8 @@ backoff==2.2.1 # server dep pyyaml==6.0.2 # server dep uvicorn==0.29.0 # server dep gunicorn==23.0.0 # server dep -fastuuid==0.12.0 # for uuid4 +# Optional performance extra: install via `pip install litellm[perf]` +# fastuuid==0.12.0 # for uuid4 uvloop==0.21.0 # uvicorn dep, gives us much better performance under load boto3==1.36.0 # aws bedrock/sagemaker calls redis==5.2.1 # redis caching @@ -58,7 +59,7 @@ tenacity==8.2.3 # for retrying requests, when litellm.num_retries set pydantic==2.10.2 # proxy + openai req. jsonschema==4.22.0 # validating json schema websockets==13.1.0 # for realtime API -pondpond==1.4.1 # for object pooling +# pondpond==1.4.1 # for object pooling ######################## # LITELLM ENTERPRISE DEPENDENCIES diff --git a/tests/test_uuid_fallback.py b/tests/test_uuid_fallback.py new file mode 100644 index 00000000000..e18bdabda8a --- /dev/null +++ b/tests/test_uuid_fallback.py @@ -0,0 +1,11 @@ +import importlib + + +def test_fastuuid_flag_exposed(): + mod = importlib.import_module("litellm._uuid") + assert hasattr(mod, "FASTUUID_AVAILABLE") + assert hasattr(mod, "uuid4") + # Ensure uuid4 returns something that looks like a UUID string + val = str(mod.uuid4()) + assert isinstance(val, str) + assert len(val) >= 8 From d40845a5fbce8f28b28a44f79f3f9981813bd17f Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 00:53:42 +0900 Subject: [PATCH 17/65] cleanup --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index a276da2da72..547cf55f1c6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -59,7 +59,7 @@ tenacity==8.2.3 # for retrying requests, when litellm.num_retries set pydantic==2.10.2 # proxy + openai req. jsonschema==4.22.0 # validating json schema websockets==13.1.0 # for realtime API -# pondpond==1.4.1 # for object pooling +pondpond==1.4.1 # for object pooling ######################## # LITELLM ENTERPRISE DEPENDENCIES From bfd6fb8981cc9930d54b05107d1197285bd2914b Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:12:02 +0900 Subject: [PATCH 18/65] uncomment fastuuid requirements.txt, move test module --- requirements.txt | 3 +-- tests/{ => test_litellm}/test_uuid_fallback.py | 0 2 files changed, 1 insertion(+), 2 deletions(-) rename tests/{ => test_litellm}/test_uuid_fallback.py (100%) diff --git a/requirements.txt b/requirements.txt index 547cf55f1c6..41f4c646958 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,8 +8,7 @@ backoff==2.2.1 # server dep pyyaml==6.0.2 # server dep uvicorn==0.29.0 # server dep gunicorn==23.0.0 # server dep -# Optional performance extra: install via `pip install litellm[perf]` -# fastuuid==0.12.0 # for uuid4 +fastuuid==0.12.0 # for uuid4 uvloop==0.21.0 # uvicorn dep, gives us much better performance under load boto3==1.36.0 # aws bedrock/sagemaker calls redis==5.2.1 # redis caching diff --git a/tests/test_uuid_fallback.py b/tests/test_litellm/test_uuid_fallback.py similarity index 100% rename from tests/test_uuid_fallback.py rename to tests/test_litellm/test_uuid_fallback.py From 0232b883252203fd8aa9cd37dc3d4e5870a001ea Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:21:49 +0900 Subject: [PATCH 19/65] move fastuuid optional dep to proxy extras --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 471e1d17387..411c1d59a0c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -93,6 +93,7 @@ proxy = [ "litellm-enterprise", "rich", "polars", + "fastuuid", ] extra_proxy = [ @@ -115,7 +116,6 @@ semantic-router = ["semantic-router"] mlflow = ["mlflow"] -perf = ["fastuuid"] [tool.isort] profile = "black" From 65df3550aa476ea853b0991c529f41682bd44671 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:25:24 +0900 Subject: [PATCH 20/65] poetry lock --- poetry.lock | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/poetry.lock b/poetry.lock index 4eb9cae6082..a8ef9ee79df 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1342,7 +1342,7 @@ description = "Python bindings to Rust's UUID library." optional = true python-versions = ">=3.8" groups = ["main"] -markers = "extra == \"perf\"" +markers = "extra == \"proxy\"" files = [ {file = "fastuuid-0.12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:22a900ef0956aacf862b460e20541fdae2d7c340594fe1bd6fdcb10d5f0791a9"}, {file = "fastuuid-0.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0302f5acf54dc75de30103025c5a95db06d6c2be36829043a0aa16fc170076bc"}, @@ -6747,12 +6747,11 @@ type = ["pytest-mypy"] caching = ["diskcache"] extra-proxy = ["azure-identity", "azure-keyvault-secrets", "google-cloud-iam", "google-cloud-kms", "prisma", "redisvl", "resend"] mlflow = ["mlflow"] -perf = ["fastuuid"] -proxy = ["PyJWT", "apscheduler", "azure-identity", "azure-storage-blob", "backoff", "boto3", "cryptography", "fastapi", "fastapi-sso", "gunicorn", "litellm-enterprise", "litellm-proxy-extras", "mcp", "orjson", "polars", "pynacl", "python-multipart", "pyyaml", "rich", "rq", "uvicorn", "uvloop", "websockets"] +proxy = ["PyJWT", "apscheduler", "azure-identity", "azure-storage-blob", "backoff", "boto3", "cryptography", "fastapi", "fastapi-sso", "fastuuid", "gunicorn", "litellm-enterprise", "litellm-proxy-extras", "mcp", "orjson", "polars", "pynacl", "python-multipart", "pyyaml", "rich", "rq", "uvicorn", "uvloop", "websockets"] semantic-router = ["semantic-router"] utils = ["numpydoc"] [metadata] lock-version = "2.1" python-versions = ">=3.8.1,<4.0, !=3.9.7" -content-hash = "608a9e7680b4109b938a642007a80cc8e8fa57142b614a17b9e9723c8380b2cd" +content-hash = "75004c6a23b70be86622fa417fd0d62fa3843e6e61c8dff8507ae5c967b7205d" From 904e56babbbe52b3cad1999b28aa1849af472956 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:34:04 +0900 Subject: [PATCH 21/65] absolute imports --- litellm/litellm_core_utils/litellm_logging.py | 2 +- litellm/llms/bedrock/common_utils.py | 2 +- litellm/proxy/common_request_processing.py | 2 +- litellm/types/utils.py | 2 +- litellm/utils.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py index 9d67ec1a867..668ba4c4b1f 100644 --- a/litellm/litellm_core_utils/litellm_logging.py +++ b/litellm/litellm_core_utils/litellm_logging.py @@ -26,7 +26,7 @@ from typing import ( cast, ) -from .._uuid import uuid +from litellm._uuid import uuid from httpx import Response from pydantic import BaseModel diff --git a/litellm/llms/bedrock/common_utils.py b/litellm/llms/bedrock/common_utils.py index edfbca8fce6..63c366c9480 100644 --- a/litellm/llms/bedrock/common_utils.py +++ b/litellm/llms/bedrock/common_utils.py @@ -774,7 +774,7 @@ class CommonBatchFilesUtils: Returns: Unique job name (ā‰¤ 63 characters for Bedrock compatibility) """ - from ..._uuid import uuid + from litellm._uuid import uuid unique_id = str(uuid.uuid4())[:8] # Format: {prefix}-batch-{model}-{uuid} # Example: litellm-batch-claude-266c398e diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py index 3807559b35d..a662015ee28 100644 --- a/litellm/proxy/common_request_processing.py +++ b/litellm/proxy/common_request_processing.py @@ -14,7 +14,7 @@ from typing import ( Union, ) -from .._uuid import uuid +from litellm._uuid import uuid import httpx import orjson from fastapi import HTTPException, Request, status diff --git a/litellm/types/utils.py b/litellm/types/utils.py index e89a98fb2e0..dcfc0f66a1d 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -13,7 +13,7 @@ from typing import ( Union, ) -from .._uuid import uuid +from litellm._uuid import uuid from aiohttp import FormData from openai._models import BaseModel as OpenAIObject from openai.types.audio.transcription_create_params import FileTypes # type: ignore diff --git a/litellm/utils.py b/litellm/utils.py index 6edb44e48d6..53a1710d685 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -40,7 +40,7 @@ from os.path import abspath, dirname, join import aiohttp import dotenv -from ._uuid import uuid +from litellm._uuid import uuid import httpx import openai import tiktoken From 6737f9e0da661a34d3bec299cece09924d1bb0c3 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:41:36 +0900 Subject: [PATCH 22/65] isort --- litellm/litellm_core_utils/litellm_logging.py | 2 +- litellm/proxy/common_request_processing.py | 2 +- litellm/types/utils.py | 2 +- litellm/utils.py | 9 +-------- 4 files changed, 4 insertions(+), 11 deletions(-) diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py index 668ba4c4b1f..2aaeed40bea 100644 --- a/litellm/litellm_core_utils/litellm_logging.py +++ b/litellm/litellm_core_utils/litellm_logging.py @@ -26,7 +26,6 @@ from typing import ( cast, ) -from litellm._uuid import uuid from httpx import Response from pydantic import BaseModel @@ -38,6 +37,7 @@ from litellm import ( turn_off_message_logging, ) from litellm._logging import _is_debugging_on, verbose_logger +from litellm._uuid import uuid from litellm.batches.batch_utils import _handle_completed_batch from litellm.caching.caching import DualCache, InMemoryCache from litellm.caching.caching_handler import LLMCachingHandler diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py index a662015ee28..95c84b914b6 100644 --- a/litellm/proxy/common_request_processing.py +++ b/litellm/proxy/common_request_processing.py @@ -14,7 +14,6 @@ from typing import ( Union, ) -from litellm._uuid import uuid import httpx import orjson from fastapi import HTTPException, Request, status @@ -22,6 +21,7 @@ from fastapi.responses import Response, StreamingResponse import litellm from litellm._logging import verbose_proxy_logger +from litellm._uuid import uuid from litellm.constants import ( DD_TRACER_STREAMING_CHUNK_YIELD_RESOURCE, STREAM_SSE_DATA_PREFIX, diff --git a/litellm/types/utils.py b/litellm/types/utils.py index dcfc0f66a1d..2ab8f844615 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -13,7 +13,6 @@ from typing import ( Union, ) -from litellm._uuid import uuid from aiohttp import FormData from openai._models import BaseModel as OpenAIObject from openai.types.audio.transcription_create_params import FileTypes # type: ignore @@ -33,6 +32,7 @@ from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, model_validator from typing_extensions import Callable, Dict, Required, TypedDict, override import litellm +from litellm._uuid import uuid from litellm.types.llms.base import ( BaseLiteLLMOpenAIResponseObject, LiteLLMPydanticObjectBase, diff --git a/litellm/utils.py b/litellm/utils.py index 53a1710d685..3f6898194f9 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -40,7 +40,6 @@ from os.path import abspath, dirname, join import aiohttp import dotenv -from litellm._uuid import uuid import httpx import openai import tiktoken @@ -59,12 +58,7 @@ import litellm.litellm_core_utils.audio_utils.utils import litellm.litellm_core_utils.json_validation_rule import litellm.llms import litellm.llms.gemini -# Import cached imports utilities -from litellm.litellm_core_utils.cached_imports import ( - get_coroutine_checker, - get_litellm_logging_class, - get_set_callbacks, -) +from litellm._uuid import uuid from litellm.caching._internal_lru_cache import lru_cache_wrapper from litellm.caching.caching import DualCache from litellm.caching.caching_handler import CachingHandlerResponse, LLMCachingHandler @@ -228,7 +222,6 @@ from typing import ( get_args, ) - from openai import OpenAIError as OriginalError from litellm.litellm_core_utils.thread_pool_executor import executor From 3158de65e1f19f2e8850457ddd4cdfb493ddf127 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:43:11 +0900 Subject: [PATCH 23/65] put back cache import utils --- litellm/utils.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/litellm/utils.py b/litellm/utils.py index 3f6898194f9..8b2b7bffb58 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -59,6 +59,12 @@ import litellm.litellm_core_utils.json_validation_rule import litellm.llms import litellm.llms.gemini from litellm._uuid import uuid +# Import cached imports utilities +from litellm.litellm_core_utils.cached_imports import ( + get_coroutine_checker, + get_litellm_logging_class, + get_set_callbacks, +) from litellm.caching._internal_lru_cache import lru_cache_wrapper from litellm.caching.caching import DualCache from litellm.caching.caching_handler import CachingHandlerResponse, LLMCachingHandler From 93e127c2f375b932d4878a0e2355e51dd3c1067b Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 01:44:53 +0900 Subject: [PATCH 24/65] cleanup --- litellm/utils.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/litellm/utils.py b/litellm/utils.py index 8b2b7bffb58..d4df9b206b5 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -59,12 +59,6 @@ import litellm.litellm_core_utils.json_validation_rule import litellm.llms import litellm.llms.gemini from litellm._uuid import uuid -# Import cached imports utilities -from litellm.litellm_core_utils.cached_imports import ( - get_coroutine_checker, - get_litellm_logging_class, - get_set_callbacks, -) from litellm.caching._internal_lru_cache import lru_cache_wrapper from litellm.caching.caching import DualCache from litellm.caching.caching_handler import CachingHandlerResponse, LLMCachingHandler @@ -87,6 +81,13 @@ from litellm.integrations.custom_logger import CustomLogger from litellm.integrations.vector_store_integrations.base_vector_store import ( BaseVectorStore, ) + +# Import cached imports utilities +from litellm.litellm_core_utils.cached_imports import ( + get_coroutine_checker, + get_litellm_logging_class, + get_set_callbacks, +) from litellm.litellm_core_utils.core_helpers import ( map_finish_reason, process_response_headers, From 311a0b335a619849c63f70af24ab7913f3f62bf4 Mon Sep 17 00:00:00 2001 From: hazyone Date: Tue, 23 Sep 2025 19:00:38 +0200 Subject: [PATCH 25/65] fix claude code max auth --- .../llm_passthrough_endpoints.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py b/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py index 5e171af5252..a834a7a13c3 100644 --- a/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py +++ b/litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py @@ -459,6 +459,14 @@ async def anthropic_proxy_route( region_name=None, ) + custom_headers = {} + if ( + "authorization" not in request.headers + and "x-api-key" not in request.headers + and anthropic_api_key is not None + ): + custom_headers["x-api-key"] = "{}".format(anthropic_api_key) + ## check for streaming is_streaming_request = await is_streaming_request_fn(request) @@ -466,7 +474,7 @@ async def anthropic_proxy_route( endpoint_func = create_pass_through_route( endpoint=endpoint, target=str(updated_url), - custom_headers={"x-api-key": "{}".format(anthropic_api_key)}, + custom_headers=custom_headers, _forward_headers=True, ) # dynamically construct pass-through endpoint based on incoming path received_value = await endpoint_func( From 04acd4b73908b31d7dfaa511e3990e1060389a48 Mon Sep 17 00:00:00 2001 From: Dharamendra Kumar Date: Tue, 23 Sep 2025 10:28:40 -0700 Subject: [PATCH 26/65] Update var name for consistency --- litellm/llms/custom_httpx/http_handler.py | 28 ++++---- litellm/llms/custom_httpx/llm_http_handler.py | 2 +- litellm/llms/openai/common_utils.py | 2 +- .../llms/custom_httpx/test_http_handler.py | 66 +++++++++---------- 4 files changed, 49 insertions(+), 49 deletions(-) diff --git a/litellm/llms/custom_httpx/http_handler.py b/litellm/llms/custom_httpx/http_handler.py index 18b0cbd594f..706b09bb098 100644 --- a/litellm/llms/custom_httpx/http_handler.py +++ b/litellm/llms/custom_httpx/http_handler.py @@ -167,7 +167,7 @@ class AsyncHTTPHandler: concurrent_limit=1000, client_alias: Optional[str] = None, # name for client in logs ssl_verify: Optional[VerifyTypes] = None, - existing_session: Optional["ClientSession"] = None, + shared_session: Optional["ClientSession"] = None, ): self.timeout = timeout self.event_hooks = event_hooks @@ -176,7 +176,7 @@ class AsyncHTTPHandler: concurrent_limit=concurrent_limit, event_hooks=event_hooks, ssl_verify=ssl_verify, - existing_session=existing_session, + shared_session=shared_session, ) self.client_alias = client_alias @@ -186,7 +186,7 @@ class AsyncHTTPHandler: concurrent_limit: int, event_hooks: Optional[Mapping[str, List[Callable[..., Any]]]], ssl_verify: Optional[VerifyTypes] = None, - existing_session: Optional["ClientSession"] = None, + shared_session: Optional["ClientSession"] = None, ) -> httpx.AsyncClient: # Get unified SSL configuration ssl_config = get_ssl_configuration(ssl_verify) @@ -202,7 +202,7 @@ class AsyncHTTPHandler: transport = AsyncHTTPHandler._create_async_transport( ssl_context=ssl_config if isinstance(ssl_config, ssl.SSLContext) else None, ssl_verify=ssl_config if isinstance(ssl_config, bool) else None, - existing_session=existing_session, + shared_session=shared_session, ) return httpx.AsyncClient( @@ -528,7 +528,7 @@ class AsyncHTTPHandler: def _create_async_transport( ssl_context: Optional[ssl.SSLContext] = None, ssl_verify: Optional[bool] = None, - existing_session: Optional["ClientSession"] = None, + shared_session: Optional["ClientSession"] = None, ) -> Optional[Union[LiteLLMAiohttpTransport, AsyncHTTPTransport]]: """ - Creates a transport for httpx.AsyncClient @@ -551,7 +551,7 @@ class AsyncHTTPHandler: return AsyncHTTPHandler._create_aiohttp_transport( ssl_context=ssl_context, ssl_verify=ssl_verify, - existing_session=existing_session, + shared_session=shared_session, ) ######################################################### @@ -619,7 +619,7 @@ class AsyncHTTPHandler: def _create_aiohttp_transport( ssl_verify: Optional[bool] = None, ssl_context: Optional[ssl.SSLContext] = None, - existing_session: Optional["ClientSession"] = None, + shared_session: Optional["ClientSession"] = None, ) -> LiteLLMAiohttpTransport: """ Creates an AiohttpTransport with RequestNotRead error handling @@ -644,12 +644,12 @@ class AsyncHTTPHandler: verbose_logger.debug("Creating AiohttpTransport...") - # Use existing session if provided and valid - if existing_session is not None and not existing_session.closed: + # Use shared session if provided and valid + if shared_session is not None and not shared_session.closed: verbose_logger.debug( - f"SHARED SESSION: Reusing existing ClientSession (ID: {id(existing_session)})" + f"SHARED SESSION: Reusing existing ClientSession (ID: {id(shared_session)})" ) - return LiteLLMAiohttpTransport(client=existing_session) + return LiteLLMAiohttpTransport(client=shared_session) # Create new session only if none provided or existing one is invalid verbose_logger.debug( @@ -941,7 +941,7 @@ class HTTPHandler: def get_async_httpx_client( llm_provider: Union[LlmProviders, httpxSpecialProvider], params: Optional[dict] = None, - existing_session: Optional["ClientSession"] = None, + shared_session: Optional["ClientSession"] = None, ) -> AsyncHTTPHandler: """ Retrieves the async HTTP client from the cache @@ -963,12 +963,12 @@ def get_async_httpx_client( return _cached_client if params is not None: - params["existing_session"] = existing_session + params["shared_session"] = shared_session _new_client = AsyncHTTPHandler(**params) else: _new_client = AsyncHTTPHandler( timeout=httpx.Timeout(timeout=600.0, connect=5.0), - existing_session=existing_session, + shared_session=shared_session, ) litellm.in_memory_llm_clients_cache.set_cache( diff --git a/litellm/llms/custom_httpx/llm_http_handler.py b/litellm/llms/custom_httpx/llm_http_handler.py index 74d438db110..f8a92c2ac96 100644 --- a/litellm/llms/custom_httpx/llm_http_handler.py +++ b/litellm/llms/custom_httpx/llm_http_handler.py @@ -246,7 +246,7 @@ class BaseLLMHTTPHandler: async_httpx_client = get_async_httpx_client( llm_provider=litellm.LlmProviders(custom_llm_provider), params={"ssl_verify": litellm_params.get("ssl_verify", None)}, - existing_session=shared_session, + shared_session=shared_session, ) else: async_httpx_client = client diff --git a/litellm/llms/openai/common_utils.py b/litellm/llms/openai/common_utils.py index 0b2daa1446c..00197a67e95 100644 --- a/litellm/llms/openai/common_utils.py +++ b/litellm/llms/openai/common_utils.py @@ -214,7 +214,7 @@ class BaseOpenAILLM: if isinstance(ssl_config, ssl.SSLContext) else None, ssl_verify=ssl_config if isinstance(ssl_config, bool) else None, - existing_session=shared_session, + shared_session=shared_session, ), follow_redirects=True, ) diff --git a/tests/test_litellm/llms/custom_httpx/test_http_handler.py b/tests/test_litellm/llms/custom_httpx/test_http_handler.py index d33a3d0918b..0e31699fd83 100644 --- a/tests/test_litellm/llms/custom_httpx/test_http_handler.py +++ b/tests/test_litellm/llms/custom_httpx/test_http_handler.py @@ -192,30 +192,30 @@ class MockClientSession: self.closed = False @pytest.mark.asyncio -async def test_create_aiohttp_transport_with_existing_session(): - """Test that _create_aiohttp_transport reuses existing session when provided""" +async def test_create_aiohttp_transport_with_shared_session(): + """Test that _create_aiohttp_transport reuses shared session when provided""" from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler - # Create a mock existing session that's not callable + # Create a mock shared session that's not callable mock_session = MockClientSession() - # Test with existing session + # Test with shared session transport = AsyncHTTPHandler._create_aiohttp_transport( - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) - # Verify the transport uses the existing session directly + # Verify the transport uses the shared session directly assert transport.client is mock_session assert not callable(transport.client) # Should not be callable @pytest.mark.asyncio -async def test_create_aiohttp_transport_without_existing_session(): +async def test_create_aiohttp_transport_without_shared_session(): """Test that _create_aiohttp_transport creates new session when none provided""" from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler - # Test without existing session - transport = AsyncHTTPHandler._create_aiohttp_transport(existing_session=None) + # Test without shared session + transport = AsyncHTTPHandler._create_aiohttp_transport(shared_session=None) # Verify the transport uses a lambda function (for backward compatibility) assert callable(transport.client) # Should be a lambda function @@ -223,7 +223,7 @@ async def test_create_aiohttp_transport_without_existing_session(): @pytest.mark.asyncio async def test_create_aiohttp_transport_with_closed_session(): - """Test that _create_aiohttp_transport creates new session when existing session is closed""" + """Test that _create_aiohttp_transport creates new session when shared session is closed""" from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler # Create a mock closed session @@ -232,7 +232,7 @@ async def test_create_aiohttp_transport_with_closed_session(): # Test with closed session transport = AsyncHTTPHandler._create_aiohttp_transport( - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) # Verify the transport creates a new session (lambda function) @@ -240,15 +240,15 @@ async def test_create_aiohttp_transport_with_closed_session(): @pytest.mark.asyncio -async def test_async_handler_with_existing_session(): - """Test AsyncHTTPHandler initialization with existing session""" +async def test_async_handler_with_shared_session(): + """Test AsyncHTTPHandler initialization with shared session""" from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler - # Create a mock existing session + # Create a mock shared session mock_session = MockClientSession() - # Create handler with existing session - handler = AsyncHTTPHandler(existing_session=mock_session) # type: ignore + # Create handler with shared session + handler = AsyncHTTPHandler(shared_session=mock_session) # type: ignore # Verify the handler was created successfully assert handler is not None @@ -256,18 +256,18 @@ async def test_async_handler_with_existing_session(): @pytest.mark.asyncio -async def test_get_async_httpx_client_with_existing_session(): - """Test get_async_httpx_client with existing session""" +async def test_get_async_httpx_client_with_shared_session(): + """Test get_async_httpx_client with shared session""" from litellm.llms.custom_httpx.http_handler import get_async_httpx_client from litellm.types.utils import LlmProviders - # Create a mock existing session + # Create a mock shared session mock_session = MockClientSession() - # Test with existing session + # Test with shared session client = get_async_httpx_client( llm_provider=LlmProviders.ANTHROPIC, - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) # Verify the client was created successfully @@ -276,15 +276,15 @@ async def test_get_async_httpx_client_with_existing_session(): @pytest.mark.asyncio -async def test_get_async_httpx_client_without_existing_session(): - """Test get_async_httpx_client without existing session (backward compatibility)""" +async def test_get_async_httpx_client_without_shared_session(): + """Test get_async_httpx_client without shared session (backward compatibility)""" from litellm.llms.custom_httpx.http_handler import get_async_httpx_client from litellm.types.utils import LlmProviders - # Test without existing session + # Test without shared session client = get_async_httpx_client( llm_provider=LlmProviders.ANTHROPIC, - existing_session=None + shared_session=None ) # Verify the client was created successfully @@ -297,19 +297,19 @@ async def test_session_reuse_chain(): """Test that session is properly passed through the entire call chain""" from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler - # Create a mock existing session + # Create a mock shared session mock_session = MockClientSession() # Test the entire chain transport = AsyncHTTPHandler._create_async_transport( - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) # Verify the transport was created assert transport is not None # Test AsyncHTTPHandler creation - handler = AsyncHTTPHandler(existing_session=mock_session) # type: ignore + handler = AsyncHTTPHandler(shared_session=mock_session) # type: ignore assert handler is not None @@ -359,12 +359,12 @@ async def test_session_reuse_integration(): # Create two clients with the same session client1 = get_async_httpx_client( llm_provider=LlmProviders.ANTHROPIC, - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) client2 = get_async_httpx_client( llm_provider=LlmProviders.OPENAI, - existing_session=mock_session # type: ignore + shared_session=mock_session # type: ignore ) # Both clients should be created successfully @@ -386,16 +386,16 @@ async def test_session_validation(): from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler # Test with None session - transport1 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=None) + transport1 = AsyncHTTPHandler._create_aiohttp_transport(shared_session=None) assert callable(transport1.client) # Should create lambda # Test with closed session mock_closed_session = MockClientSession() mock_closed_session.closed = True - transport2 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=mock_closed_session) # type: ignore + transport2 = AsyncHTTPHandler._create_aiohttp_transport(shared_session=mock_closed_session) # type: ignore assert callable(transport2.client) # Should create lambda # Test with valid session mock_valid_session = MockClientSession() - transport3 = AsyncHTTPHandler._create_aiohttp_transport(existing_session=mock_valid_session) # type: ignore + transport3 = AsyncHTTPHandler._create_aiohttp_transport(shared_session=mock_valid_session) # type: ignore assert transport3.client is mock_valid_session # Should reuse session From 96aed6a4d4cc3d431e34cc03dfdf65f07652814a Mon Sep 17 00:00:00 2001 From: hazyone Date: Tue, 23 Sep 2025 20:16:05 +0200 Subject: [PATCH 27/65] test added --- .../test_anthropic_auth_headers.py | 218 ++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 tests/test_litellm/proxy/pass_through_endpoints/test_anthropic_auth_headers.py diff --git a/tests/test_litellm/proxy/pass_through_endpoints/test_anthropic_auth_headers.py b/tests/test_litellm/proxy/pass_through_endpoints/test_anthropic_auth_headers.py new file mode 100644 index 00000000000..9872ed2c9d1 --- /dev/null +++ b/tests/test_litellm/proxy/pass_through_endpoints/test_anthropic_auth_headers.py @@ -0,0 +1,218 @@ +import os +import sys +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + +sys.path.insert( + 0, os.path.abspath("../../..") +) # Adds the parent directory to the system path + +from litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints import ( + anthropic_proxy_route, +) + + +class TestAnthropicAuthHeaders: + """Test authentication header handling in anthropic_proxy_route.""" + + @pytest.fixture + def mock_request(self): + """Create a mock request object.""" + request = MagicMock() + request.method = "POST" + request.headers = {} + return request + + @pytest.fixture + def mock_response(self): + """Create a mock FastAPI response object.""" + return MagicMock() + + @pytest.fixture + def mock_user_api_key_dict(self): + """Create a mock user API key dict.""" + return {"user_id": "test_user"} + + @pytest.mark.asyncio + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.create_pass_through_route") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.is_streaming_request_fn") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.passthrough_endpoint_router") + async def test_client_authorization_header_priority( + self, + mock_router, + mock_streaming, + mock_create_route, + mock_request, + mock_response, + mock_user_api_key_dict, + ): + """Test that client Authorization header takes priority over server key.""" + # Setup + mock_request.headers = {"authorization": "Bearer client-key-123"} + mock_router.get_credentials.return_value = "server-key-456" + mock_streaming.return_value = False + mock_endpoint_func = AsyncMock(return_value="test_response") + mock_create_route.return_value = mock_endpoint_func + + # Act + await anthropic_proxy_route( + endpoint="v1/messages", + request=mock_request, + fastapi_response=mock_response, + user_api_key_dict=mock_user_api_key_dict, + ) + + # Assert + mock_create_route.assert_called_once() + call_kwargs = mock_create_route.call_args[1] + + assert call_kwargs["custom_headers"] == {} + assert call_kwargs["_forward_headers"] is True + + @pytest.mark.asyncio + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.create_pass_through_route") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.is_streaming_request_fn") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.passthrough_endpoint_router") + async def test_client_x_api_key_header_priority( + self, + mock_router, + mock_streaming, + mock_create_route, + mock_request, + mock_response, + mock_user_api_key_dict, + ): + """Test that client x-api-key header takes priority over server key.""" + # Setup + mock_request.headers = {"x-api-key": "client-x-api-key-123"} + mock_router.get_credentials.return_value = "server-key-456" + mock_streaming.return_value = False + mock_endpoint_func = AsyncMock(return_value="test_response") + mock_create_route.return_value = mock_endpoint_func + + # Act + await anthropic_proxy_route( + endpoint="v1/messages", + request=mock_request, + fastapi_response=mock_response, + user_api_key_dict=mock_user_api_key_dict, + ) + + # Assert + mock_create_route.assert_called_once() + call_kwargs = mock_create_route.call_args[1] + + assert call_kwargs["custom_headers"] == {} + assert call_kwargs["_forward_headers"] is True + + @pytest.mark.asyncio + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.create_pass_through_route") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.is_streaming_request_fn") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.passthrough_endpoint_router") + async def test_server_api_key_fallback( + self, + mock_router, + mock_streaming, + mock_create_route, + mock_request, + mock_response, + mock_user_api_key_dict, + ): + """Test that server API key is used when no client authentication is provided.""" + # Setup + mock_request.headers = {} # No authentication headers + mock_router.get_credentials.return_value = "server-key-456" + mock_streaming.return_value = False + mock_endpoint_func = AsyncMock(return_value="test_response") + mock_create_route.return_value = mock_endpoint_func + + # Act + await anthropic_proxy_route( + endpoint="v1/messages", + request=mock_request, + fastapi_response=mock_response, + user_api_key_dict=mock_user_api_key_dict, + ) + + # Assert + mock_create_route.assert_called_once() + call_kwargs = mock_create_route.call_args[1] + + assert call_kwargs["custom_headers"] == {"x-api-key": "server-key-456"} + assert call_kwargs["_forward_headers"] is True + + @pytest.mark.asyncio + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.create_pass_through_route") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.is_streaming_request_fn") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.passthrough_endpoint_router") + async def test_no_authentication_available( + self, + mock_router, + mock_streaming, + mock_create_route, + mock_request, + mock_response, + mock_user_api_key_dict, + ): + """Test that no x-api-key header is added when no authentication is available.""" + # Setup + mock_request.headers = {} # No authentication headers + mock_router.get_credentials.return_value = None # No server key + mock_streaming.return_value = False + mock_endpoint_func = AsyncMock(return_value="test_response") + mock_create_route.return_value = mock_endpoint_func + + # Act + await anthropic_proxy_route( + endpoint="v1/messages", + request=mock_request, + fastapi_response=mock_response, + user_api_key_dict=mock_user_api_key_dict, + ) + + # Assert + mock_create_route.assert_called_once() + call_kwargs = mock_create_route.call_args[1] + + assert call_kwargs["custom_headers"] == {} + assert call_kwargs["_forward_headers"] is True + + @pytest.mark.asyncio + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.create_pass_through_route") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.is_streaming_request_fn") + @patch("litellm.proxy.pass_through_endpoints.llm_passthrough_endpoints.passthrough_endpoint_router") + async def test_both_client_headers_present( + self, + mock_router, + mock_streaming, + mock_create_route, + mock_request, + mock_response, + mock_user_api_key_dict, + ): + """Test that no server key is added when client has both auth headers.""" + # Setup + mock_request.headers = { + "authorization": "Bearer client-auth-key", + "x-api-key": "client-x-api-key" + } + mock_router.get_credentials.return_value = "server-key-456" + mock_streaming.return_value = False + mock_endpoint_func = AsyncMock(return_value="test_response") + mock_create_route.return_value = mock_endpoint_func + + # Act + await anthropic_proxy_route( + endpoint="v1/messages", + request=mock_request, + fastapi_response=mock_response, + user_api_key_dict=mock_user_api_key_dict, + ) + + # Assert + mock_create_route.assert_called_once() + call_kwargs = mock_create_route.call_args[1] + + assert call_kwargs["custom_headers"] == {} + assert call_kwargs["_forward_headers"] is True \ No newline at end of file From 1585a1ba8e7292ae2898614507f50c97a769ccfa Mon Sep 17 00:00:00 2001 From: Jack Temple Date: Tue, 23 Sep 2025 14:35:53 -0500 Subject: [PATCH 28/65] fix: SSO clear button now properly clears settings instead of creating empty encrypted values --- .../proxy_setting_endpoints.py | 29 ++- .../test_proxy_setting_endpoints.py | 204 ++++++++++++++++++ .../src/components/SSOModals.tsx | 28 +-- 3 files changed, 238 insertions(+), 23 deletions(-) diff --git a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py index 83acf0e8226..e2ca3078384 100644 --- a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py +++ b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py @@ -493,21 +493,32 @@ async def update_sso_settings(sso_config: SSOConfig): config["general_settings"] = {} # Update environment variables in config and in memory - sso_data = sso_config.model_dump(exclude_none=True) + sso_data = sso_config.model_dump() for field_name, value in sso_data.items(): - - if field_name == "user_email" and value is not None: - # Store user_email in general_settings instead of environment variables - config["general_settings"]["proxy_admin_email"] = value - elif field_name == "ui_access_mode" and value is not None: - - config["general_settings"]["ui_access_mode"] = value - elif field_name in env_var_mapping and value is not None: + if field_name == "user_email": + if value: + # Store user_email in general_settings instead of environment variables + config["general_settings"]["proxy_admin_email"] = value + else: + # Clear user_email if null/empty + config["general_settings"].pop("proxy_admin_email", None) + elif field_name == "ui_access_mode": + if value: + config["general_settings"]["ui_access_mode"] = value + else: + # Clear ui_access_mode if null/empty + config["general_settings"].pop("ui_access_mode", None) + elif field_name in env_var_mapping and value: env_var_name = env_var_mapping[field_name] # Update in config config["environment_variables"][env_var_name] = value # Update in runtime environment os.environ[env_var_name] = value + elif field_name in env_var_mapping: + # Clear environment variable if value is null/empty + env_var_name = env_var_mapping[field_name] + config["environment_variables"].pop(env_var_name, None) + os.environ.pop(env_var_name, None) stored_config = config if len(config["environment_variables"]) > 0: diff --git a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py index 395f12ca111..ef733eaa887 100644 --- a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py +++ b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py @@ -322,3 +322,207 @@ class TestProxySettingEndpoints: # Verify save_config was called exactly once assert mock_proxy_config["save_call_count"]() == 1 + + def test_update_sso_settings_with_null_values_clears_env_vars( + self, mock_proxy_config, mock_auth, monkeypatch + ): + """Test that updating SSO settings with null values clears environment variables""" + monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key") + + # First, verify we have existing environment variables + initial_config = mock_proxy_config["config"] + assert "GOOGLE_CLIENT_ID" in initial_config["environment_variables"] + assert "MICROSOFT_CLIENT_ID" in initial_config["environment_variables"] + + # Set some initial environment variables for runtime testing + monkeypatch.setenv("GOOGLE_CLIENT_ID", "test_existing_google_id") + monkeypatch.setenv("MICROSOFT_CLIENT_ID", "test_existing_microsoft_id") + + # Send SSO settings with null values to clear them + clear_sso_settings = { + "google_client_id": None, + "google_client_secret": None, + "microsoft_client_id": None, + "microsoft_client_secret": None, + "microsoft_tenant": None, + "generic_client_id": None, + "generic_client_secret": None, + "generic_authorization_endpoint": None, + "generic_token_endpoint": None, + "generic_userinfo_endpoint": None, + "proxy_base_url": None, + "user_email": None, + "sso_provider": None, + } + + response = client.patch("/update/sso_settings", json=clear_sso_settings) + + assert response.status_code == 200 + data = response.json() + assert data["status"] == "success" + + # Verify that environment variables were cleared from config + updated_config = mock_proxy_config["config"] + + # These should be removed from environment_variables + assert "GOOGLE_CLIENT_ID" not in updated_config["environment_variables"] + assert "GOOGLE_CLIENT_SECRET" not in updated_config["environment_variables"] + assert "MICROSOFT_CLIENT_ID" not in updated_config["environment_variables"] + assert "MICROSOFT_CLIENT_SECRET" not in updated_config["environment_variables"] + assert "MICROSOFT_TENANT" not in updated_config["environment_variables"] + assert "PROXY_BASE_URL" not in updated_config["environment_variables"] + + # Verify that runtime environment variables were cleared + assert "GOOGLE_CLIENT_ID" not in os.environ + assert "MICROSOFT_CLIENT_ID" not in os.environ + + # Verify user_email was cleared from general_settings + assert updated_config["general_settings"].get("proxy_admin_email") is None + + # Verify save_config was called + assert mock_proxy_config["save_call_count"]() == 1 + + def test_update_sso_settings_with_empty_strings_clears_env_vars( + self, mock_proxy_config, mock_auth, monkeypatch + ): + """Test that updating SSO settings with empty strings also clears environment variables""" + monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key") + + # Set some initial environment variables for runtime testing + monkeypatch.setenv("GOOGLE_CLIENT_ID", "test_existing_google_id") + monkeypatch.setenv("MICROSOFT_CLIENT_SECRET", "test_existing_microsoft_secret") + + # Send SSO settings with empty strings to clear them + clear_sso_settings = { + "google_client_id": "", + "google_client_secret": "", + "microsoft_client_secret": "", + "proxy_base_url": "", + "user_email": "", + } + + response = client.patch("/update/sso_settings", json=clear_sso_settings) + + assert response.status_code == 200 + data = response.json() + assert data["status"] == "success" + + # Verify that environment variables with empty strings were cleared from config + updated_config = mock_proxy_config["config"] + assert "GOOGLE_CLIENT_ID" not in updated_config["environment_variables"] + assert "GOOGLE_CLIENT_SECRET" not in updated_config["environment_variables"] + assert "MICROSOFT_CLIENT_SECRET" not in updated_config["environment_variables"] + assert "PROXY_BASE_URL" not in updated_config["environment_variables"] + + # Verify that runtime environment variables were cleared + assert "GOOGLE_CLIENT_ID" not in os.environ + assert "MICROSOFT_CLIENT_SECRET" not in os.environ + + # Verify user_email was cleared from general_settings + assert updated_config["general_settings"].get("proxy_admin_email") is None + + # Verify save_config was called + assert mock_proxy_config["save_call_count"]() == 1 + + def test_update_sso_settings_mixed_null_and_valid_values( + self, mock_proxy_config, mock_auth, monkeypatch + ): + """Test updating SSO settings with mix of null and valid values""" + monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key") + + # Set some initial environment variables + monkeypatch.setenv("GOOGLE_CLIENT_ID", "old_google_id") + monkeypatch.setenv("MICROSOFT_CLIENT_ID", "old_microsoft_id") + monkeypatch.setenv("PROXY_BASE_URL", "old_proxy_url") + + # Send mixed SSO settings - some null, some valid + mixed_sso_settings = { + "google_client_id": "new_google_client_id", # Valid value + "google_client_secret": None, # Null to clear + "microsoft_client_id": None, # Null to clear + "microsoft_client_secret": "new_microsoft_secret", # Valid value + "proxy_base_url": "https://newproxy.com", # Valid value + "user_email": None, # Null to clear + } + + response = client.patch("/update/sso_settings", json=mixed_sso_settings) + + assert response.status_code == 200 + data = response.json() + assert data["status"] == "success" + + # Verify the config was updated correctly + updated_config = mock_proxy_config["config"] + + # Valid values should be set + assert ( + updated_config["environment_variables"]["GOOGLE_CLIENT_ID"] + != "new_google_client_id" + ) # Encrypted + assert ( + updated_config["environment_variables"]["MICROSOFT_CLIENT_SECRET"] + != "new_microsoft_secret" + ) # Encrypted + assert ( + updated_config["environment_variables"]["PROXY_BASE_URL"] + != "https://newproxy.com" + ) # Encrypted + + # Null values should be cleared + assert "GOOGLE_CLIENT_SECRET" not in updated_config["environment_variables"] + assert "MICROSOFT_CLIENT_ID" not in updated_config["environment_variables"] + + # Verify runtime environment variables + assert os.environ.get("GOOGLE_CLIENT_ID") == "new_google_client_id" + assert os.environ.get("MICROSOFT_CLIENT_SECRET") == "new_microsoft_secret" + assert "GOOGLE_CLIENT_SECRET" not in os.environ + assert "MICROSOFT_CLIENT_ID" not in os.environ + + # Verify user_email was cleared from general_settings + assert updated_config["general_settings"].get("proxy_admin_email") is None + + # Verify save_config was called + assert mock_proxy_config["save_call_count"]() == 1 + + def test_update_sso_settings_ui_access_mode_handling( + self, mock_proxy_config, mock_auth, monkeypatch + ): + """Test that ui_access_mode is handled correctly in general_settings""" + monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key") + + # Test setting ui_access_mode + sso_settings_with_ui_mode = { + "ui_access_mode": "admin_only", + "user_email": "admin@test.com", + } + + response = client.patch("/update/sso_settings", json=sso_settings_with_ui_mode) + + assert response.status_code == 200 + data = response.json() + assert data["status"] == "success" + + # Verify ui_access_mode was set in general_settings (not environment_variables) + updated_config = mock_proxy_config["config"] + assert updated_config["general_settings"]["ui_access_mode"] == "admin_only" + assert ( + updated_config["general_settings"]["proxy_admin_email"] == "admin@test.com" + ) + + # Verify ui_access_mode is NOT in environment_variables + assert "ui_access_mode" not in updated_config["environment_variables"] + + # Test clearing ui_access_mode + clear_ui_mode = {"ui_access_mode": None, "user_email": None} + + response = client.patch("/update/sso_settings", json=clear_ui_mode) + + assert response.status_code == 200 + + # Verify ui_access_mode and user_email were cleared + updated_config = mock_proxy_config["config"] + assert updated_config["general_settings"].get("ui_access_mode") is None + assert updated_config["general_settings"].get("proxy_admin_email") is None + + # Verify save_config was called twice (once for each update) + assert mock_proxy_config["save_call_count"]() == 2 diff --git a/ui/litellm-dashboard/src/components/SSOModals.tsx b/ui/litellm-dashboard/src/components/SSOModals.tsx index 4920cec03b3..56ec9393fa4 100644 --- a/ui/litellm-dashboard/src/components/SSOModals.tsx +++ b/ui/litellm-dashboard/src/components/SSOModals.tsx @@ -186,21 +186,21 @@ const SSOModals: React.FC = ({ } try { - // Clear all SSO settings by sending empty values + // Clear all SSO settings const clearSettings = { - google_client_id: '', - google_client_secret: '', - microsoft_client_id: '', - microsoft_client_secret: '', - microsoft_tenant: '', - generic_client_id: '', - generic_client_secret: '', - generic_authorization_endpoint: '', - generic_token_endpoint: '', - generic_userinfo_endpoint: '', - proxy_base_url: '', - user_email: '', - sso_provider: '', + google_client_id: null, + google_client_secret: null, + microsoft_client_id: null, + microsoft_client_secret: null, + microsoft_tenant: null, + generic_client_id: null, + generic_client_secret: null, + generic_authorization_endpoint: null, + generic_token_endpoint: null, + generic_userinfo_endpoint: null, + proxy_base_url: null, + user_email: null, + sso_provider: null, }; await updateSSOSettings(accessToken, clearSettings); From 426c6fea9f35c6eab33e70f423b542376848e857 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 13:59:54 -0700 Subject: [PATCH 29/65] Revert "Merge pull request #14761 from uzaxirr/feat/sdk-additional-headers" This reverts commit 8628c265b98363c8173b2288a11208e4904ca7fc, reversing changes made to be193fbffd5d41a8bb8edd2cbf8e73b925a6a12c. --- docs/my-website/docs/sdk/headers.md | 328 ---------------------------- examples/sdk_headers_example.py | 195 ----------------- litellm/main.py | 80 ++++--- tests/test_litellm/test_main.py | 278 +++-------------------- 4 files changed, 78 insertions(+), 803 deletions(-) delete mode 100644 docs/my-website/docs/sdk/headers.md delete mode 100644 examples/sdk_headers_example.py diff --git a/docs/my-website/docs/sdk/headers.md b/docs/my-website/docs/sdk/headers.md deleted file mode 100644 index a1fdaadc6f5..00000000000 --- a/docs/my-website/docs/sdk/headers.md +++ /dev/null @@ -1,328 +0,0 @@ -# SDK Header Support - -LiteLLM SDK provides comprehensive support for passing additional headers with API requests. This is essential for enterprise environments using API gateways, service meshes, and multi-tenant architectures. - -## Overview - -Headers can be passed to LiteLLM in three ways, with the following priority order: -1. **Request-specific headers** (highest priority) -2. **extra_headers parameter** -3. **Global litellm.headers** (lowest priority) - -When the same header key is specified in multiple places, the higher priority value will be used. - -## Usage Methods - -### 1. Global Headers (litellm.headers) - -Set headers that will be included in all API requests: - -```python -import litellm - -# Set global headers for all requests -litellm.headers = { - "X-API-Gateway-Key": "your-gateway-key", - "X-Company-ID": "acme-corp", - "X-Environment": "production" -} - -# Now all completion calls will include these headers -response = litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": "Hello"}] -) -``` - -### 2. Per-Request Headers (extra_headers) - -Pass headers for specific requests using the `extra_headers` parameter: - -```python -import litellm - -response = litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-Request-ID": "req-12345", - "X-Tenant-ID": "tenant-abc", - "X-Custom-Auth": "bearer-token-xyz" - } -) -``` - -### 3. Request Headers (headers parameter) - -Use the `headers` parameter for the highest priority header control: - -```python -import litellm - -response = litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": "Hello"}], - headers={ - "X-Priority-Header": "high-priority-value", - "Authorization": "Bearer custom-token" - } -) -``` - -### 4. Combining All Methods - -You can combine all three methods. Headers will be merged with the priority order: - -```python -import litellm - -# Global headers (lowest priority) -litellm.headers = { - "X-Company-ID": "acme-corp", - "X-Shared-Header": "global-value" -} - -response = litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-Request-ID": "req-12345", - "X-Shared-Header": "extra-value" # Overrides global - }, - headers={ - "X-Priority-Header": "important", - "X-Shared-Header": "request-value" # Overrides both global and extra - } -) - -# Final headers sent to API: -# { -# "X-Company-ID": "acme-corp", # From global -# "X-Request-ID": "req-12345", # From extra_headers -# "X-Priority-Header": "important", # From headers -# "X-Shared-Header": "request-value" # From headers (highest priority) -# } -``` - -## Enterprise Use Cases - -### API Gateway Integration (Apigee, Kong, AWS API Gateway) - -```python -import litellm - -# Set up headers for API gateway routing and authentication -litellm.headers = { - "X-API-Gateway-Key": "your-gateway-key", - "X-Route-Version": "v2" -} - -# Per-tenant requests -response = litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": "Analyze this data"}], - extra_headers={ - "X-Tenant-ID": "tenant-123", - "X-Department": "engineering" - } -) -``` - -### Service Mesh (Istio, Linkerd) - -```python -import litellm - -response = litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-Trace-ID": "trace-abc-123", - "X-Service-Name": "ai-service", - "X-Version": "1.2.3" - } -) -``` - -### Multi-Tenant SaaS Applications - -```python -import litellm - -def make_ai_request(user_id, tenant_id, content): - return litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": content}], - extra_headers={ - "X-User-ID": user_id, - "X-Tenant-ID": tenant_id, - "X-Request-Time": str(int(time.time())) - } - ) - -# Usage -response = make_ai_request("user-456", "tenant-org-1", "Help me write code") -``` - -### Request Tracing and Debugging - -```python -import litellm -import uuid - -def traced_completion(model, messages, **kwargs): - trace_id = str(uuid.uuid4()) - - return litellm.completion( - model=model, - messages=messages, - extra_headers={ - "X-Trace-ID": trace_id, - "X-Debug-Mode": "true", - "X-Source-Service": "my-app" - }, - **kwargs - ) - -# Usage -response = traced_completion( - model="gpt-4", - messages=[{"role": "user", "content": "Debug this issue"}] -) -``` - -### Custom Authentication - -```python -import litellm - -def get_custom_auth_token(): - # Your custom authentication logic - return "custom-auth-token" - -response = litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": "Hello"}], - headers={ - "X-Custom-Auth": get_custom_auth_token(), - "X-Auth-Type": "custom" - } -) -``` - -## Provider Support - -Headers are supported across all LiteLLM providers including: - -- **OpenAI** (GPT models) -- **Anthropic** (Claude models) -- **Cohere** -- **Hugging Face** -- **Custom providers** -- **Azure OpenAI** -- **AWS Bedrock** -- **Google Vertex AI** - -Each provider will receive your custom headers along with their required authentication and API-specific headers. - -## Best Practices - -### 1. Use Meaningful Header Names -```python -# Good -extra_headers = { - "X-Request-ID": "req-12345", - "X-Tenant-ID": "org-456" -} - -# Avoid -extra_headers = { - "custom1": "value1", - "h2": "value2" -} -``` - -### 2. Include Tracing Information -```python -extra_headers = { - "X-Trace-ID": trace_id, - "X-Span-ID": span_id, - "X-Service-Name": "ai-service" -} -``` - -### 3. Handle Sensitive Information Carefully -```python -# Don't log sensitive headers -import os - -if os.getenv("ENVIRONMENT") != "production": - extra_headers["X-Debug-User"] = user_id -``` - -### 4. Use Environment-Specific Headers -```python -import os - -environment = os.getenv("ENVIRONMENT", "development") - -litellm.headers = { - "X-Environment": environment, - "X-Service-Version": os.getenv("SERVICE_VERSION", "unknown") -} -``` - -## Troubleshooting - -### Headers Not Being Passed - -If your headers aren't reaching the API: - -1. **Check Header Names**: Ensure header names don't conflict with provider-specific headers -2. **Verify Priority**: Remember that `headers` > `extra_headers` > `litellm.headers` -3. **Test with Logging**: Enable verbose logging to see what headers are being sent - -```python -import litellm - -# Enable debug logging -litellm.set_verbose = True - -response = litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "test"}], - extra_headers={"X-Debug": "test"} -) -``` - -### Gateway or Proxy Issues - -If using API gateways or proxies: - -1. **Check Gateway Requirements**: Verify required headers for your gateway -2. **Test Direct vs Gateway**: Compare direct API calls vs gateway calls -3. **Validate Header Format**: Some gateways have header format requirements - -## Security Considerations - -1. **Don't Log Sensitive Headers**: Avoid logging authentication tokens or personal data -2. **Use HTTPS**: Always use secure connections when passing sensitive headers -3. **Validate Header Values**: Sanitize user-provided header values -4. **Rotate Keys**: Regularly rotate any API keys passed in headers - -```python -import litellm -import re - -def safe_header_value(value): - # Remove potentially dangerous characters - return re.sub(r'[^\w\-.]', '', str(value)) - -response = litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-User-ID": safe_header_value(user_id) - } -) -``` \ No newline at end of file diff --git a/examples/sdk_headers_example.py b/examples/sdk_headers_example.py deleted file mode 100644 index 4ce31df4a70..00000000000 --- a/examples/sdk_headers_example.py +++ /dev/null @@ -1,195 +0,0 @@ -#!/usr/bin/env python3 -""" -Example demonstrating LiteLLM SDK header support for enterprise environments. - -This example shows how to use additional headers with API gateways, service meshes, -and multi-tenant architectures. -""" - -import litellm -import os -from typing import Dict, Any - -def example_global_headers(): - """Example: Set global headers for all requests""" - print("=== Global Headers Example ===") - - # Set global headers that will be included in all API requests - litellm.headers = { - "X-API-Gateway-Key": "your-gateway-key-here", - "X-Company-ID": "acme-corp", - "X-Environment": "production" - } - - print("Global headers set:", litellm.headers) - - # These headers will now be included in all completion calls - # (Note: This example doesn't actually make API calls) - print("Global headers will be included in all subsequent completion() calls") - - -def example_per_request_headers(): - """Example: Using extra_headers for specific requests""" - print("\n=== Per-Request Headers Example ===") - - headers_to_send = { - "X-Request-ID": "req-12345", - "X-Tenant-ID": "tenant-abc", - "X-Custom-Auth": "bearer-token-xyz" - } - - print("Per-request headers:", headers_to_send) - - # Example of how you would use extra_headers in a real call - # response = litellm.completion( - # model="claude-3-5-sonnet-latest", - # messages=[{"role": "user", "content": "Hello"}], - # extra_headers=headers_to_send - # ) - - -def example_header_priority(): - """Example: Demonstrating header priority and merging""" - print("\n=== Header Priority Example ===") - - # Set global headers - litellm.headers = { - "X-Company-ID": "acme-corp", - "X-Shared-Header": "global-value" - } - - # Headers that would be sent in a request - extra_headers = { - "X-Request-ID": "req-12345", - "X-Shared-Header": "extra-value" # Overrides global - } - - request_headers = { - "X-Priority-Header": "important", - "X-Shared-Header": "request-value" # Overrides both global and extra - } - - print("Global headers:", litellm.headers) - print("Extra headers:", extra_headers) - print("Request headers:", request_headers) - print("\nFinal headers would be:") - print(" X-Company-ID: acme-corp (from global)") - print(" X-Request-ID: req-12345 (from extra)") - print(" X-Priority-Header: important (from request)") - print(" X-Shared-Header: request-value (request wins - highest priority)") - - -def example_enterprise_api_gateway(): - """Example: Enterprise API Gateway scenario""" - print("\n=== Enterprise API Gateway Example ===") - - # Simulate enterprise environment with Apigee or similar - gateway_config = { - "X-API-Gateway-Key": os.getenv("API_GATEWAY_KEY", "demo-key"), - "X-Route-Version": "v2", - "X-Rate-Limit-Group": "premium" - } - - # Set gateway headers globally - litellm.headers = gateway_config - print("Gateway headers configured:", gateway_config) - - # Function to make tenant-specific requests - def make_tenant_request(tenant_id: str, user_id: str, content: str) -> Dict[str, Any]: - """Make an AI request with tenant-specific headers""" - - tenant_headers = { - "X-Tenant-ID": tenant_id, - "X-User-ID": user_id, - "X-Request-Time": "2024-01-01T00:00:00Z", - "X-Service-Name": "ai-assistant" - } - - print(f"Making request for tenant {tenant_id}, user {user_id}") - print("Tenant-specific headers:", tenant_headers) - - # In a real scenario, this would make the actual API call: - # return litellm.completion( - # model="claude-3-5-sonnet-latest", - # messages=[{"role": "user", "content": content}], - # extra_headers=tenant_headers - # ) - - # For demo purposes, return mock data - return {"mock": "response", "headers_used": {**gateway_config, **tenant_headers}} - - # Example usage - result = make_tenant_request("tenant-123", "user-456", "Analyze this data") - print("Response:", result) - - -def example_service_mesh(): - """Example: Service mesh integration (Istio, Linkerd)""" - print("\n=== Service Mesh Example ===") - - service_mesh_headers = { - "X-Trace-ID": "trace-abc-123", - "X-Span-ID": "span-def-456", - "X-Service-Name": "ai-service", - "X-Version": "1.2.3", - "X-Cluster": "prod-us-west-2" - } - - print("Service mesh headers:", service_mesh_headers) - - # Example of using these headers for distributed tracing - # response = litellm.completion( - # model="gpt-4", - # messages=[{"role": "user", "content": "Hello"}], - # extra_headers=service_mesh_headers - # ) - - -def example_debugging_and_monitoring(): - """Example: Request debugging and monitoring""" - print("\n=== Debugging and Monitoring Example ===") - - import uuid - import time - - # Generate unique identifiers for request tracking - trace_id = str(uuid.uuid4()) - request_id = f"req-{int(time.time())}" - - debug_headers = { - "X-Trace-ID": trace_id, - "X-Request-ID": request_id, - "X-Debug-Mode": "true", - "X-Source-Service": "customer-support-bot", - "X-Request-Priority": "high" - } - - print("Debug headers:", debug_headers) - print(f"Trace ID: {trace_id}") - print(f"Request ID: {request_id}") - - # These headers help with: - # 1. Distributed tracing across services - # 2. Request correlation in logs - # 3. Debug mode enablement - # 4. Priority-based routing - - -if __name__ == "__main__": - print("LiteLLM SDK Header Support Examples") - print("=" * 50) - - example_global_headers() - example_per_request_headers() - example_header_priority() - example_enterprise_api_gateway() - example_service_mesh() - example_debugging_and_monitoring() - - print("\n" + "=" * 50) - print("All examples completed!") - print("\nTo use in your application:") - print("1. Set litellm.headers for global headers") - print("2. Use extra_headers parameter for request-specific headers") - print("3. Use headers parameter for highest priority headers") - print("4. Headers are merged with priority: headers > extra_headers > litellm.headers") \ No newline at end of file diff --git a/litellm/main.py b/litellm/main.py index 5493c7e34e3..924e06492a6 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -1004,15 +1004,7 @@ def completion( # type: ignore # noqa: PLR0915 provider_specific_header = cast( Optional[ProviderSpecificHeader], kwargs.get("provider_specific_header", None) ) - # Properly merge headers with priority: request headers > extra_headers > global litellm.headers - headers = {} - if litellm.headers is not None and isinstance(litellm.headers, dict): - headers.update(litellm.headers) - if extra_headers is not None and isinstance(extra_headers, dict): - headers.update(extra_headers) - request_headers = kwargs.get("headers", None) - if request_headers is not None and isinstance(request_headers, dict): - headers.update(request_headers) + headers = kwargs.get("headers", None) or extra_headers ensure_alternating_roles: Optional[bool] = kwargs.get( "ensure_alternating_roles", None @@ -1023,6 +1015,10 @@ def completion( # type: ignore # noqa: PLR0915 assistant_continue_message: Optional[ChatCompletionAssistantMessage] = kwargs.get( "assistant_continue_message", None ) + if headers is None: + headers = {} + if extra_headers is not None: + headers.update(extra_headers) num_retries = kwargs.get( "num_retries", None ) ## alt. param for 'max_retries'. Use this to pass retries w/ instructor. @@ -1079,6 +1075,7 @@ def completion( # type: ignore # noqa: PLR0915 prompt_id=prompt_id, non_default_params=non_default_params ) ): + ( model, messages, @@ -1431,7 +1428,8 @@ def completion( # type: ignore # noqa: PLR0915 "azure_ad_token_provider", None ) - # Use the consolidated headers that were already merged at the top of the function + headers = headers or litellm.headers + if extra_headers is not None: optional_params["extra_headers"] = extra_headers if max_retries is not None: @@ -1696,7 +1694,8 @@ def completion( # type: ignore # noqa: PLR0915 or get_secret("OPENAI_API_KEY") ) - # Use the consolidated headers that were already merged at the top of the function + headers = headers or litellm.headers + if extra_headers is not None: optional_params["extra_headers"] = extra_headers @@ -2034,6 +2033,7 @@ def completion( # type: ignore # noqa: PLR0915 try: if use_base_llm_http_handler: + response = base_llm_http_handler.completion( model=model, messages=messages, @@ -2412,8 +2412,12 @@ def completion( # type: ignore # noqa: PLR0915 or "https://api.cohere.ai/v1/chat" ) - # Use the consolidated headers that were already merged at the top of the function - # No need for additional merging here as it's already done + headers = headers or litellm.headers or {} + if headers is None: + headers = {} + + if extra_headers is not None: + headers.update(extra_headers) response = base_llm_http_handler.completion( model=model, @@ -2509,10 +2513,15 @@ def completion( # type: ignore # noqa: PLR0915 ) elif custom_llm_provider == "compactifai": api_key = ( - api_key or get_secret_str("COMPACTIFAI_API_KEY") or litellm.api_key + api_key + or get_secret_str("COMPACTIFAI_API_KEY") + or litellm.api_key ) - api_base = api_base or "https://api.compactif.ai/v1" + api_base = ( + api_base + or "https://api.compactif.ai/v1" + ) ## COMPLETION CALL response = base_llm_http_handler.completion( @@ -3098,9 +3107,9 @@ def completion( # type: ignore # noqa: PLR0915 "aws_region_name" not in optional_params or optional_params["aws_region_name"] is None ): - optional_params[ - "aws_region_name" - ] = aws_bedrock_client.meta.region_name + optional_params["aws_region_name"] = ( + aws_bedrock_client.meta.region_name + ) bedrock_route = BedrockModelInfo.get_bedrock_route(model) if bedrock_route == "converse": @@ -3442,6 +3451,7 @@ def completion( # type: ignore # noqa: PLR0915 ) raise e elif custom_llm_provider == "gradient_ai": + api_base = litellm.api_base or api_base response = base_llm_http_handler.completion( model=model, @@ -3801,7 +3811,7 @@ def embedding( *, aembedding: Literal[True], **kwargs, -) -> Coroutine[Any, Any, EmbeddingResponse]: +) -> Coroutine[Any, Any, EmbeddingResponse]: ... @@ -3827,7 +3837,7 @@ def embedding( *, aembedding: Literal[False] = False, **kwargs, -) -> EmbeddingResponse: +) -> EmbeddingResponse: ... # fmt: on @@ -4138,8 +4148,10 @@ def embedding( # noqa: PLR0915 or litellm.api_key ) - # Use the consolidated headers that were already merged at the top of the function - # No need for additional merging here as it's already done + if extra_headers is not None and isinstance(extra_headers, dict): + headers = extra_headers + else: + headers = {} response = base_llm_http_handler.embedding( model=model, @@ -5099,9 +5111,9 @@ def adapter_completion( new_kwargs = translation_obj.translate_completion_input_params(kwargs=kwargs) response: Union[ModelResponse, CustomStreamWrapper] = completion(**new_kwargs) # type: ignore - translated_response: Optional[ - Union[BaseModel, AdapterCompletionStreamWrapper] - ] = None + translated_response: Optional[Union[BaseModel, AdapterCompletionStreamWrapper]] = ( + None + ) if isinstance(response, ModelResponse): translated_response = translation_obj.translate_completion_output_params( response=response @@ -6089,9 +6101,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(content_chunks) > 0: - response["choices"][0]["message"][ - "content" - ] = processor.get_combined_content(content_chunks) + response["choices"][0]["message"]["content"] = ( + processor.get_combined_content(content_chunks) + ) thinking_blocks = [ chunk @@ -6102,9 +6114,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(thinking_blocks) > 0: - response["choices"][0]["message"][ - "thinking_blocks" - ] = processor.get_combined_thinking_content(thinking_blocks) + response["choices"][0]["message"]["thinking_blocks"] = ( + processor.get_combined_thinking_content(thinking_blocks) + ) reasoning_chunks = [ chunk @@ -6115,9 +6127,9 @@ def stream_chunk_builder( # noqa: PLR0915 ] if len(reasoning_chunks) > 0: - response["choices"][0]["message"][ - "reasoning_content" - ] = processor.get_combined_reasoning_content(reasoning_chunks) + response["choices"][0]["message"]["reasoning_content"] = ( + processor.get_combined_reasoning_content(reasoning_chunks) + ) audio_chunks = [ chunk diff --git a/tests/test_litellm/test_main.py b/tests/test_litellm/test_main.py index 631592f4c1f..954597dda25 100644 --- a/tests/test_litellm/test_main.py +++ b/tests/test_litellm/test_main.py @@ -5,6 +5,7 @@ import sys import httpx import pytest import respx +from fastapi.testclient import TestClient sys.path.insert( 0, os.path.abspath("../..") @@ -175,7 +176,7 @@ async def test_url_with_format_param(model, sync_mode, monkeypatch): else: response = await acompletion(**args, client=client) print(response) - except Exception: + except Exception as e: pass mock_client.assert_called() @@ -268,6 +269,7 @@ def test_bedrock_latency_optimized_inference(): def test_custom_provider_with_extra_headers(): + from litellm.llms.custom_httpx.http_handler import HTTPHandler with patch.object( litellm.llms.custom_httpx.http_handler.HTTPHandler, "post" @@ -284,6 +286,7 @@ def test_custom_provider_with_extra_headers(): def test_custom_provider_with_extra_body(): + from litellm.llms.custom_httpx.http_handler import HTTPHandler with patch.object( litellm.llms.custom_httpx.http_handler.HTTPHandler, "post" @@ -1129,57 +1132,52 @@ def test_anthropic_disable_url_suffix_env_var(): # Test with environment variable disabled (default behavior) with patch.dict(os.environ, {"ANTHROPIC_API_BASE": "https://api.example.com"}): actual_api_base = None - + with patch("litellm.main.anthropic_chat_completions") as mock_anthropic: - def capture_completion(**kwargs): nonlocal actual_api_base actual_api_base = kwargs.get("api_base") mock_response = MagicMock() mock_response.choices = [MagicMock()] return mock_response - + mock_anthropic.completion = capture_completion - + # This should append /v1/messages completion( model="anthropic/claude-3-sonnet", messages=[{"role": "user", "content": "test"}], - api_key="test-key", + api_key="test-key" ) - + # Verify the api_base has /v1/messages appended assert actual_api_base.endswith("/v1/messages") assert actual_api_base == "https://api.example.com/v1/messages" # Test with environment variable enabled - with patch.dict( - os.environ, - { - "ANTHROPIC_API_BASE": "https://api.example.com/custom/path", - "LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX": "true", - }, - ): + with patch.dict(os.environ, { + "ANTHROPIC_API_BASE": "https://api.example.com/custom/path", + "LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX": "true" + }): actual_api_base = None - + with patch("litellm.main.anthropic_chat_completions") as mock_anthropic: - def capture_completion(**kwargs): nonlocal actual_api_base actual_api_base = kwargs.get("api_base") mock_response = MagicMock() mock_response.choices = [MagicMock()] return mock_response - + mock_anthropic.completion = capture_completion - + # This should NOT append /v1/messages completion( model="anthropic/claude-3-sonnet", messages=[{"role": "user", "content": "test"}], - api_key="test-key", + api_key="test-key" ) - + # Verify the api_base does not have /v1/messages appended assert actual_api_base == "https://api.example.com/custom/path" assert not actual_api_base.endswith("/v1/messages") @@ -1194,260 +1192,48 @@ def test_anthropic_text_disable_url_suffix_env_var(): # Test with environment variable disabled (default behavior) with patch.dict(os.environ, {"ANTHROPIC_API_BASE": "https://api.example.com"}): actual_api_base = None - + with patch("litellm.main.base_llm_http_handler") as mock_handler: - def capture_completion(**kwargs): nonlocal actual_api_base actual_api_base = kwargs.get("api_base") return MagicMock() - + mock_handler.completion = capture_completion - + # This should append /v1/complete completion( model="anthropic_text/claude-instant-1", messages=[{"role": "user", "content": "test"}], - api_key="test-key", + api_key="test-key" ) - + # Verify the api_base has /v1/complete appended assert actual_api_base.endswith("/v1/complete") assert actual_api_base == "https://api.example.com/v1/complete" # Test with environment variable enabled - with patch.dict( - os.environ, - { - "ANTHROPIC_API_BASE": "https://api.example.com/custom/complete", - "LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX": "true", - }, - ): + with patch.dict(os.environ, { + "ANTHROPIC_API_BASE": "https://api.example.com/custom/complete", + "LITELLM_ANTHROPIC_DISABLE_URL_SUFFIX": "true" + }): actual_api_base = None - + with patch("litellm.main.base_llm_http_handler") as mock_handler: - def capture_completion(**kwargs): nonlocal actual_api_base actual_api_base = kwargs.get("api_base") return MagicMock() - + mock_handler.completion = capture_completion - + # This should NOT append /v1/complete completion( model="anthropic_text/claude-instant-1", messages=[{"role": "user", "content": "test"}], - api_key="test-key", + api_key="test-key" ) - + # Verify the api_base does not have /v1/complete appended assert actual_api_base == "https://api.example.com/custom/complete" assert not actual_api_base.endswith("/v1/complete") - - -# Test header handling functionality -def test_header_priority_and_merging(): - """Test that headers are properly merged with correct priority: request headers > extra_headers > global litellm.headers""" - import litellm - from unittest.mock import patch, MagicMock - - # Store original headers to restore later - original_headers = litellm.headers - - try: - # Set global headers - litellm.headers = { - "X-Global-Header": "global-value", - "X-Shared-Header": "global", - } - - captured_headers = {} - - with patch( - "litellm.llms.custom_httpx.http_handler.HTTPHandler.post" - ) as mock_post: - - def capture_headers(*args, **kwargs): - captured_headers.update(kwargs.get("headers", {})) - mock_response = MagicMock() - mock_response.json.return_value = { - "choices": [{"message": {"content": "test"}}], - "usage": {"total_tokens": 10}, - } - mock_response.status_code = 200 - return mock_response - - mock_post.side_effect = capture_headers - - # Test header merging - try: - litellm.completion( - model="custom/test-model", - messages=[{"role": "user", "content": "test"}], - api_base="https://example.com/api", - extra_headers={ - "X-Extra-Header": "extra-value", - "X-Shared-Header": "extra", - }, - headers={ - "X-Request-Header": "request-value", - "X-Shared-Header": "request", - }, - ) - except Exception: - # Expected since we're mocking - pass - - # Verify header priority: request > extra > global - assert "X-Global-Header" in captured_headers - assert "X-Extra-Header" in captured_headers - assert "X-Request-Header" in captured_headers - assert captured_headers["X-Global-Header"] == "global-value" - assert captured_headers["X-Extra-Header"] == "extra-value" - assert captured_headers["X-Request-Header"] == "request-value" - # Request headers should override others - assert captured_headers["X-Shared-Header"] == "request" - - finally: - # Restore original headers - litellm.headers = original_headers - - -def test_anthropic_header_passing(): - """Test that custom headers are properly passed to Anthropic API calls""" - from unittest.mock import patch, MagicMock - - captured_headers = {} - - with patch("litellm.llms.anthropic.chat.handler.HTTPHandler.post") as mock_post: - - def capture_headers(*args, **kwargs): - captured_headers.update(kwargs.get("headers", {})) - mock_response = MagicMock() - mock_response.json.return_value = { - "content": [{"text": "test response"}], - "usage": {"input_tokens": 5, "output_tokens": 5}, - } - mock_response.status_code = 200 - return mock_response - - mock_post.side_effect = capture_headers - - try: - litellm.completion( - model="claude-3-5-sonnet-latest", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-API-Gateway-Key": "gateway-123", - "X-Tenant-ID": "tenant-456", - }, - ) - except Exception: - # Expected since we're mocking - pass - - # Verify custom headers are included along with anthropic headers - assert "X-API-Gateway-Key" in captured_headers - assert "X-Tenant-ID" in captured_headers - assert captured_headers["X-API-Gateway-Key"] == "gateway-123" - assert captured_headers["X-Tenant-ID"] == "tenant-456" - # Verify anthropic-specific headers are also present - assert "x-api-key" in captured_headers - assert "anthropic-version" in captured_headers - - -def test_openai_header_passing(): - """Test that custom headers are properly passed to OpenAI API calls""" - from unittest.mock import patch, MagicMock - - captured_extra_headers = {} - - with patch( - "litellm.llms.openai.chat.gpt_transformation.OpenAIGPTConfig.transform_request" - ) as mock_transform: - with patch("litellm.completion_cost") as mock_cost: - mock_cost.return_value = 0.0 - mock_transform.return_value = {"model": "gpt-4", "messages": []} - - with patch("openai.OpenAI") as mock_openai: - mock_client = MagicMock() - mock_openai.return_value = mock_client - mock_response = MagicMock() - mock_response.choices = [MagicMock()] - mock_response.choices[0].message.content = "test response" - mock_response.usage.total_tokens = 10 - mock_client.chat.completions.create.return_value = mock_response - - try: - litellm.completion( - model="gpt-4", - messages=[{"role": "user", "content": "Hello"}], - extra_headers={ - "X-Custom-Auth": "bearer-token", - "X-Request-ID": "req-789", - }, - ) - except Exception: - # Expected since we're mocking - pass - - # Verify extra_headers were passed to the OpenAI client - call_args = mock_client.chat.completions.create.call_args - if call_args: - kwargs = call_args.kwargs - assert "extra_headers" in kwargs - extra_headers = kwargs["extra_headers"] - assert "X-Custom-Auth" in extra_headers - assert "X-Request-ID" in extra_headers - - -def test_global_headers_functionality(): - """Test that global litellm.headers work correctly""" - import litellm - from unittest.mock import patch, MagicMock - - # Store original headers to restore later - original_headers = litellm.headers - - try: - # Set global headers - litellm.headers = {"X-Company-ID": "acme-corp", "X-Environment": "production"} - - captured_headers = {} - - with patch( - "litellm.llms.custom_httpx.http_handler.HTTPHandler.post" - ) as mock_post: - - def capture_headers(*args, **kwargs): - captured_headers.update(kwargs.get("headers", {})) - mock_response = MagicMock() - mock_response.json.return_value = { - "choices": [{"message": {"content": "test"}}], - "usage": {"total_tokens": 10}, - } - mock_response.status_code = 200 - return mock_response - - mock_post.side_effect = capture_headers - - try: - litellm.completion( - model="custom/test-model", - messages=[{"role": "user", "content": "test"}], - api_base="https://example.com/api", - ) - except Exception: - # Expected since we're mocking - pass - - # Verify global headers are included - assert "X-Company-ID" in captured_headers - assert "X-Environment" in captured_headers - assert captured_headers["X-Company-ID"] == "acme-corp" - assert captured_headers["X-Environment"] == "production" - - finally: - # Restore original headers - litellm.headers = original_headers From 724d8b5afa53192c1d3e5e38c80e7be3994241c6 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:01:48 -0700 Subject: [PATCH 30/65] fix linting --- litellm/main.py | 2 +- litellm/model_prices_and_context_window_backup.json | 4 +++- litellm/proxy/_experimental/mcp_server/server.py | 2 +- litellm/proxy/management_endpoints/ui_sso.py | 4 ++-- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/litellm/main.py b/litellm/main.py index 924e06492a6..f9c44b00e86 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -3615,7 +3615,7 @@ def completion( # type: ignore # noqa: PLR0915 async_fn=acompletion, stream=stream, custom_llm=custom_handler ) - headers = headers or litellm.headers + headers = headers or litellm.headers or {} ## CALL FUNCTION response = handler_fn( diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 578523abff4..5ca0bf08ba9 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -12332,6 +12332,7 @@ "supports_response_schema": true, "supports_system_messages": true, "supports_tool_choice": true, + "supports_service_tier": true, "supports_vision": true }, "gpt-5-chat": { @@ -12479,6 +12480,7 @@ "cache_read_input_token_cost_flex": 2.5e-09, "input_cost_per_token": 5e-08, "input_cost_per_token_flex": 2.5e-08, + "input_cost_per_token_priority": 2.5e-06, "litellm_provider": "openai", "max_input_tokens": 400000, "max_output_tokens": 128000, @@ -15452,7 +15454,7 @@ }, "o4-mini": { "cache_read_input_token_cost": 2.75e-07, - "cache_read_input_token_cost_flex": 1.38e-07, + "cache_read_input_token_cost_flex": 1.375e-07, "cache_read_input_token_cost_priority": 5e-07, "input_cost_per_token": 1.1e-06, "input_cost_per_token_flex": 5.5e-07, diff --git a/litellm/proxy/_experimental/mcp_server/server.py b/litellm/proxy/_experimental/mcp_server/server.py index 8558229cf0b..1205d3790af 100644 --- a/litellm/proxy/_experimental/mcp_server/server.py +++ b/litellm/proxy/_experimental/mcp_server/server.py @@ -674,7 +674,7 @@ if MCP_AVAILABLE: server_name = single_server_match.group(1) mcp_servers_from_path = [server_name] else: - mcp_servers_from_path = [servers_and_path] + mcp_servers_from_path = [mcp_servers_str] return mcp_servers_from_path async def extract_mcp_auth_context(scope, path): diff --git a/litellm/proxy/management_endpoints/ui_sso.py b/litellm/proxy/management_endpoints/ui_sso.py index 3828f7318c1..e8074332f5a 100644 --- a/litellm/proxy/management_endpoints/ui_sso.py +++ b/litellm/proxy/management_endpoints/ui_sso.py @@ -810,7 +810,7 @@ async def cli_poll_key(key_id: str): key_obj = await prisma_client.db.litellm_verificationtoken.find_unique( where={"token": hashed_token} ) - key_obj: LiteLLM_VerificationToken = cast(LiteLLM_VerificationToken, key_obj) + key_obj = cast(LiteLLM_VerificationToken, key_obj) if key_obj: verbose_proxy_logger.info(f"CLI key found: {key_id}") @@ -1503,7 +1503,7 @@ class SSOAuthenticationHandler: ## CHECK IF ROLE ALLOWED TO USE PROXY ## is_admin_only_access = check_is_admin_only_access(ui_access_mode or {}) if is_admin_only_access: - has_access = has_admin_ui_access(user_role) + has_access = has_admin_ui_access(user_role or "") if not has_access: raise HTTPException( status_code=401, From 298b0a50a75a72816f9ed941bf1f607b5c1240a0 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:02:28 -0700 Subject: [PATCH 31/65] fix linting --- litellm/proxy/management_endpoints/ui_sso.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/management_endpoints/ui_sso.py b/litellm/proxy/management_endpoints/ui_sso.py index e8074332f5a..637a852087d 100644 --- a/litellm/proxy/management_endpoints/ui_sso.py +++ b/litellm/proxy/management_endpoints/ui_sso.py @@ -1547,7 +1547,7 @@ class SSOAuthenticationHandler: user_id=cast(str, user_id), key=key, user_email=user_email, - user_role=user_role, + user_role=user_role or LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value, login_method="sso", premium_user=premium_user, auth_header_name=general_settings.get( From d91e533d8eab42fa7af570da013f1a374b01fa8e Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:07:33 -0700 Subject: [PATCH 32/65] refactor --- litellm/proxy/client/cli/commands/auth.py | 62 ++++++++++++---------- litellm/proxy/client/cli/commands/teams.py | 24 +++------ 2 files changed, 40 insertions(+), 46 deletions(-) diff --git a/litellm/proxy/client/cli/commands/auth.py b/litellm/proxy/client/cli/commands/auth.py index 9be74268059..ae795316a2d 100644 --- a/litellm/proxy/client/cli/commands/auth.py +++ b/litellm/proxy/client/cli/commands/auth.py @@ -301,6 +301,37 @@ def update_key_with_team(base_url: str, api_key: str, team_id: str) -> bool: # Polling-based authentication - no local server needed +def _handle_team_assignment(base_url: str, api_key: str, user_id: str) -> None: + """Handle team fetching and assignment for the authenticated user.""" + click.echo("\n" + "="*60) + click.echo("šŸ“‹ Fetching your teams...") + + teams = get_user_teams( + base_url=base_url, + api_key=api_key, + user_id=user_id, + ) + + if teams: + # Prompt for team selection (will display teams interactively) + selected_team = prompt_team_selection(teams) + + if selected_team: + team_id = selected_team.get('team_id') + if team_id: + click.echo(f"\nšŸ”„ Assigning your key to team: {selected_team.get('team_alias', team_id)}") + success = update_key_with_team(base_url, api_key, team_id) + if success: + click.echo(f"āœ… Your CLI key is now associated with team: {selected_team.get('team_alias', team_id)}") + click.echo(f"šŸŽÆ You can now access models: {', '.join(selected_team.get('models', ['All models']))}") + else: + click.echo("āš ļø Key assignment failed, but you can still use the CLI") + else: + click.echo("ā„¹ļø Continuing without team assignment. You can assign a team later using the CLI.") + else: + click.echo("ā„¹ļø No teams found. You can create or join teams using the web interface.") + + @click.command(name="login") @click.pass_context def login(ctx: click.Context): @@ -364,35 +395,8 @@ def login(ctx: click.Context): click.echo(f"API Key: {api_key[:20]}...") click.echo("You can now use the CLI without specifying --api-key") - # Fetch and display user's teams - click.echo("\n" + "="*60) - click.echo("šŸ“‹ Fetching your teams...") - - teams = get_user_teams( - base_url=base_url, - api_key=api_key, - user_id=data.get("user_id"), - ) - - - if teams: - # Prompt for team selection (will display teams interactively) - selected_team = prompt_team_selection(teams) - - if selected_team: - team_id = selected_team.get('team_id') - if team_id: - click.echo(f"\nšŸ”„ Assigning your key to team: {selected_team.get('team_alias', team_id)}") - success = update_key_with_team(base_url, api_key, team_id) - if success: - click.echo(f"āœ… Your CLI key is now associated with team: {selected_team.get('team_alias', team_id)}") - click.echo(f"šŸŽÆ You can now access models: {', '.join(selected_team.get('models', ['All models']))}") - else: - click.echo("āš ļø Key assignment failed, but you can still use the CLI") - else: - click.echo("ā„¹ļø Continuing without team assignment. You can assign a team later using the CLI.") - else: - click.echo("ā„¹ļø No teams found. You can create or join teams using the web interface.") + # Handle team assignment + _handle_team_assignment(base_url, api_key, data.get("user_id")) # Show available commands after successful login click.echo("\n" + "="*60) diff --git a/litellm/proxy/client/cli/commands/teams.py b/litellm/proxy/client/cli/commands/teams.py index d4e05c890dc..57397ca01a0 100644 --- a/litellm/proxy/client/cli/commands/teams.py +++ b/litellm/proxy/client/cli/commands/teams.py @@ -80,11 +80,8 @@ def list(ctx: click.Context): display_teams_table(teams) except requests.exceptions.HTTPError as e: click.echo(f"Error: HTTP {e.response.status_code}", err=True) - try: - error_body = e.response.json() - click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) - except: - click.echo(e.response.text, err=True) + error_body = e.response.json() + click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) raise click.Abort() except Exception as e: click.echo(f"Error: {str(e)}", err=True) @@ -107,12 +104,8 @@ def available(ctx: click.Context): click.echo("ā„¹ļø No available teams to join.") except requests.exceptions.HTTPError as e: click.echo(f"Error: HTTP {e.response.status_code}", err=True) - try: - error_body = e.response.json() - click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) - except: - click.echo(e.response.text, err=True) - raise click.Abort() + error_body = e.response.json() + click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) except Exception as e: click.echo(f"Error: {str(e)}", err=True) raise click.Abort() @@ -152,7 +145,7 @@ def assign_key(ctx: click.Context, team_id: Optional[str]): # Update the key with the selected team if team_id: click.echo(f"\nšŸ”„ Assigning your key to team: {team_id}") - result = client.keys.update(key=api_key, team_id=team_id) + client.keys.update(key=api_key, team_id=team_id) click.echo(f"āœ… Successfully assigned key to team: {team_id}") # Show team details if available @@ -168,11 +161,8 @@ def assign_key(ctx: click.Context, team_id: Optional[str]): except requests.exceptions.HTTPError as e: click.echo(f"Error: HTTP {e.response.status_code}", err=True) - try: - error_body = e.response.json() - click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) - except: - click.echo(e.response.text, err=True) + error_body = e.response.json() + click.echo(f"Details: {error_body.get('detail', 'Unknown error')}", err=True) raise click.Abort() except Exception as e: click.echo(f"Error: {str(e)}", err=True) From 29a82c977350458caef18cc03e6e7d4faccd1d20 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:07:54 -0700 Subject: [PATCH 33/65] fix ruff --- litellm/proxy/client/cli/commands/auth.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/client/cli/commands/auth.py b/litellm/proxy/client/cli/commands/auth.py index ae795316a2d..54d51db8b43 100644 --- a/litellm/proxy/client/cli/commands/auth.py +++ b/litellm/proxy/client/cli/commands/auth.py @@ -286,7 +286,7 @@ def update_key_with_team(base_url: str, api_key: str, team_id: str) -> bool: client = Client(base_url=base_url, api_key=api_key) try: - result = client.keys.update(key=api_key, team_id=team_id) + client.keys.update(key=api_key, team_id=team_id) click.echo(f"āœ… Successfully assigned key to team: {team_id}") return True except requests.exceptions.HTTPError as e: From a88d774f9467d09c3ce638759a268968d9823001 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:14:43 -0700 Subject: [PATCH 34/65] Revert "Merge pull request #14720 from uc4w6c/feat/remove-servername-prefix-mcp_tools" This reverts commit 7216983f485f2606b91f1f60c5b84cdc6e4b3e07, reversing changes made to e377e30e95a404e90621d211e12ee6562de271b3. --- .../mcp_server/mcp_server_manager.py | 19 +-- .../mcp_server/rest_endpoints.py | 1 - .../proxy/_experimental/mcp_server/server.py | 52 +++----- .../mcp_server/test_mcp_server.py | 122 +----------------- .../mcp_server/test_mcp_server_manager.py | 106 --------------- 5 files changed, 29 insertions(+), 271 deletions(-) diff --git a/litellm/proxy/_experimental/mcp_server/mcp_server_manager.py b/litellm/proxy/_experimental/mcp_server/mcp_server_manager.py index 1e7840d95b3..ab5d1b10bf3 100644 --- a/litellm/proxy/_experimental/mcp_server/mcp_server_manager.py +++ b/litellm/proxy/_experimental/mcp_server/mcp_server_manager.py @@ -421,7 +421,6 @@ class MCPServerManager: self, server: MCPServer, mcp_auth_header: Optional[str] = None, - add_prefix: bool = True, ) -> List[MCPTool]: """ Helper method to get tools from a single MCP server with prefixed names. @@ -446,11 +445,9 @@ class MCPServerManager: tools = await self._fetch_tools_with_timeout(client, server.name) - prefixed_or_original_tools = self._create_prefixed_tools( - tools, server, add_prefix=add_prefix - ) + prefixed_tools = self._create_prefixed_tools(tools, server) - return prefixed_or_original_tools + return prefixed_tools except Exception as e: verbose_logger.warning( @@ -519,7 +516,7 @@ class MCPServerManager: return [] def _create_prefixed_tools( - self, tools: List[MCPTool], server: MCPServer, add_prefix: bool = True + self, tools: List[MCPTool], server: MCPServer ) -> List[MCPTool]: """ Create prefixed tools and update tool mapping. @@ -537,16 +534,14 @@ class MCPServerManager: for tool in tools: prefixed_name = add_server_prefix_to_tool_name(tool.name, prefix) - name_to_use = prefixed_name if add_prefix else tool.name - - tool_obj = MCPTool( - name=name_to_use, + prefixed_tool = MCPTool( + name=prefixed_name, description=tool.description, inputSchema=tool.inputSchema, ) - prefixed_tools.append(tool_obj) + prefixed_tools.append(prefixed_tool) - # Update tool to server mapping for resolution (support both forms) + # Update tool to server mapping with both original and prefixed names self.tool_name_to_mcp_server_name_mapping[tool.name] = prefix self.tool_name_to_mcp_server_name_mapping[prefixed_name] = prefix diff --git a/litellm/proxy/_experimental/mcp_server/rest_endpoints.py b/litellm/proxy/_experimental/mcp_server/rest_endpoints.py index 399b79b4f7c..2a9174717d1 100644 --- a/litellm/proxy/_experimental/mcp_server/rest_endpoints.py +++ b/litellm/proxy/_experimental/mcp_server/rest_endpoints.py @@ -73,7 +73,6 @@ if MCP_AVAILABLE: tools = await global_mcp_server_manager._get_tools_from_server( server=server, mcp_auth_header=server_auth_header, - add_prefix=False, ) return _create_tool_response_objects(tools, server.mcp_info) diff --git a/litellm/proxy/_experimental/mcp_server/server.py b/litellm/proxy/_experimental/mcp_server/server.py index 1205d3790af..b6259b385fa 100644 --- a/litellm/proxy/_experimental/mcp_server/server.py +++ b/litellm/proxy/_experimental/mcp_server/server.py @@ -384,9 +384,6 @@ if MCP_AVAILABLE: allowed_mcp_servers=allowed_mcp_servers, ) - # Decide whether to add prefix based on number of allowed servers - add_prefix = not (len(allowed_mcp_servers) == 1) - # Get tools from each allowed server all_tools = [] for server_id in allowed_mcp_servers: @@ -409,7 +406,6 @@ if MCP_AVAILABLE: tools = await global_mcp_server_manager._get_tools_from_server( server=server, mcp_auth_header=server_auth_header, - add_prefix=add_prefix, ) all_tools.extend(tools) verbose_logger.debug( @@ -641,35 +637,27 @@ if MCP_AVAILABLE: # Server names can contain slashes (e.g., "custom_solutions/user_123") mcp_path_match = re.match(r"^/mcp/([^?#]+)(?:\?.*)?(?:#.*)?$", path) if mcp_path_match: - mcp_servers_str = mcp_path_match.group(1) - optional_path = mcp_path_match.group(2) - - if mcp_servers_str: - # First, try to split by comma for comma-separated lists - if "," in mcp_servers_str: - # For comma-separated lists, we need to handle the case where the last item - # might include the path (e.g., "zapier,group1/tools" -> ["zapier", "group1/tools"]) - parts = [s.strip() for s in mcp_servers_str.split(",") if s.strip()] - - # If there's an optional path AND the last part contains a slash that matches the optional path, - # remove the path portion from the last server name - if optional_path and len(parts) > 0 and "/" in parts[-1]: - last_part = parts[-1] - # Check if the last part ends with the optional path - if optional_path and last_part.endswith( - optional_path.lstrip("/") - ): - # Remove the path portion from the last server name - parts[-1] = last_part[: -len(optional_path.lstrip("/"))] - - mcp_servers_from_path = parts + servers_and_path = mcp_path_match.group(1) + + if servers_and_path: + # Check if it contains commas (comma-separated servers) + if ',' in servers_and_path: + # For comma-separated, look for a path at the end + # Common patterns: /tools, /chat/completions, etc. + path_match = re.search(r'/([^/,]+(?:/[^/,]+)*)$', servers_and_path) + if path_match: + # Path found at the end, remove it from servers + path_part = '/' + path_match.group(1) + servers_part = servers_and_path[:-len(path_part)] + mcp_servers_from_path = [s.strip() for s in servers_part.split(',') if s.strip()] + else: + # No path, just comma-separated servers + mcp_servers_from_path = [s.strip() for s in servers_and_path.split(',') if s.strip()] else: - # For single server, it might be just a name or contain slashes - # We need to determine where the server name ends and the path begins - # This is tricky - let's use the original logic but handle comma cases differently - single_server_match = re.match( - r"^([^/]+(?:/[^/]+)?)(?:/.*)?$", mcp_servers_str - ) + # Single server case - use regex approach for server/path separation + # This handles cases like "custom_solutions/user_123/chat/completions" + # where we want to extract "custom_solutions/user_123" as the server name + single_server_match = re.match(r"^([^/]+(?:/[^/]+)?)(?:/.*)?$", servers_and_path) if single_server_match: server_name = single_server_match.group(1) mcp_servers_from_path = [server_name] diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server.py index 754487d11e7..8fa9964b1fc 100644 --- a/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server.py +++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server.py @@ -102,7 +102,7 @@ async def test_get_tools_from_mcp_servers_continues_when_one_server_fails(): working_server if server_id == "working_server" else failing_server ) - async def mock_get_tools_from_server(server, mcp_auth_header=None, add_prefix=True): + async def mock_get_tools_from_server(server, mcp_auth_header=None): if server.name == "working_server": # Working server returns tools tool1 = MagicMock() @@ -184,7 +184,7 @@ async def test_get_tools_from_mcp_servers_handles_all_servers_failing(): failing_server1 if server_id == "failing_server1" else failing_server2 ) - async def mock_get_tools_from_server(server, mcp_auth_header=None, add_prefix=True): + async def mock_get_tools_from_server(server, mcp_auth_header=None): # All servers fail raise Exception(f"Server {server.name} connection failed") @@ -448,121 +448,3 @@ async def test_mcp_routing_with_conflicting_alias_and_group_name(): assert ( called_servers[0].server_id == specific_server.server_id ), "Should have contacted the specific server alias, not the group." - - -@pytest.mark.asyncio -async def test_list_tools_single_server_unprefixed_names(): - """When only one MCP server is allowed, list tools should return unprefixed names.""" - try: - from litellm.proxy._experimental.mcp_server.server import ( - _get_tools_from_mcp_servers, - set_auth_context, - ) - except ImportError: - pytest.skip("MCP server not available") - - # Mock user auth - user_api_key_auth = UserAPIKeyAuth(api_key="test_key", user_id="test_user") - set_auth_context(user_api_key_auth) - - # One allowed server - server = MagicMock() - server.server_id = "server1" - server.name = "Zapier MCP" - server.alias = "zapier" - - # Mock manager: allow just one server and return a tool based on add_prefix flag - mock_manager = MagicMock() - mock_manager.get_allowed_mcp_servers = AsyncMock(return_value=["server1"]) - mock_manager.get_mcp_server_by_id = ( - lambda server_id: server if server_id == "server1" else None - ) - - async def mock_get_tools_from_server( - server, mcp_auth_header=None, add_prefix=False - ): - tool = MagicMock() - tool.name = f"{server.alias}-toolA" if add_prefix else "toolA" - tool.description = "desc" - tool.inputSchema = {} - return [tool] - - mock_manager._get_tools_from_server = mock_get_tools_from_server - - with patch( - "litellm.proxy._experimental.mcp_server.server.global_mcp_server_manager", - mock_manager, - ): - tools = await _get_tools_from_mcp_servers( - user_api_key_auth=user_api_key_auth, - mcp_auth_header=None, - mcp_servers=None, - mcp_server_auth_headers=None, - ) - - # Should be unprefixed since only one server is allowed - assert len(tools) == 1 - assert tools[0].name == "toolA" - - -@pytest.mark.asyncio -async def test_list_tools_multiple_servers_prefixed_names(): - """When multiple MCP servers are allowed, list tools should return prefixed names.""" - try: - from litellm.proxy._experimental.mcp_server.server import ( - _get_tools_from_mcp_servers, - set_auth_context, - ) - except ImportError: - pytest.skip("MCP server not available") - - # Mock user auth - user_api_key_auth = UserAPIKeyAuth(api_key="test_key", user_id="test_user") - set_auth_context(user_api_key_auth) - - # Two allowed servers - server1 = MagicMock() - server1.server_id = "server1" - server1.name = "Zapier MCP" - server1.alias = "zapier" - - server2 = MagicMock() - server2.server_id = "server2" - server2.name = "Jira MCP" - server2.alias = "jira" - - # Mock manager - mock_manager = MagicMock() - mock_manager.get_allowed_mcp_servers = AsyncMock( - return_value=["server1", "server2"] - ) - mock_manager.get_mcp_server_by_id = ( - lambda server_id: server1 if server_id == "server1" else server2 - ) - - async def mock_get_tools_from_server( - server, mcp_auth_header=None, add_prefix=True - ): - tool = MagicMock() - # When multiple servers, add_prefix should be True -> prefixed names - tool.name = f"{server.alias}-toolA" if add_prefix else "toolA" - tool.description = "desc" - tool.inputSchema = {} - return [tool] - - mock_manager._get_tools_from_server = mock_get_tools_from_server - - with patch( - "litellm.proxy._experimental.mcp_server.server.global_mcp_server_manager", - mock_manager, - ): - tools = await _get_tools_from_mcp_servers( - user_api_key_auth=user_api_key_auth, - mcp_auth_header=None, - mcp_servers=None, - mcp_server_auth_headers=None, - ) - - # Should be prefixed since multiple servers are allowed - names = sorted([t.name for t in tools]) - assert names == ["jira-toolA", "zapier-toolA"] diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server_manager.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server_manager.py index e3bb085d5f4..3237de37636 100644 --- a/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server_manager.py +++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_mcp_server_manager.py @@ -420,112 +420,6 @@ class TestMCPServerManager: assert result["status"] == "healthy" assert result["tools_count"] == 1 - @pytest.mark.asyncio - async def test_get_tools_from_server_add_prefix(self): - """Verify _get_tools_from_server respects add_prefix True/False.""" - manager = MCPServerManager() - - # Create a minimal server with alias used as prefix - server = MCPServer( - server_id="zapier", - name="zapier", - transport=MCPTransport.http, - ) - - # Mock client creation and fetching tools - manager._create_mcp_client = MagicMock(return_value=object()) - - # Tools returned upstream (unprefixed from provider) - upstream_tool = MagicMock() - upstream_tool.name = "send_email" - upstream_tool.description = "Send an email" - upstream_tool.inputSchema = {} - - manager._fetch_tools_with_timeout = AsyncMock(return_value=[upstream_tool]) - - # Case 1: add_prefix=True (default for multi-server) -> expect prefixed - tools_prefixed = await manager._get_tools_from_server(server, add_prefix=True) - assert len(tools_prefixed) == 1 - assert tools_prefixed[0].name == "zapier-send_email" - - # Case 2: add_prefix=False (single-server) -> expect unprefixed - tools_unprefixed = await manager._get_tools_from_server( - server, add_prefix=False - ) - assert len(tools_unprefixed) == 1 - assert tools_unprefixed[0].name == "send_email" - - def test_create_prefixed_tools_updates_mapping_for_both_forms(self): - """_create_prefixed_tools should populate mapping for prefixed and original names even when not adding prefix in output.""" - manager = MCPServerManager() - - server = MCPServer( - server_id="jira", - name="jira", - transport=MCPTransport.http, - ) - - # Input tools as would come from upstream - t1 = MagicMock() - t1.name = "create_issue" - t1.description = "" - t1.inputSchema = {} - t2 = MagicMock() - t2.name = "close_issue" - t2.description = "" - t2.inputSchema = {} - - # Do not add prefix in returned objects - out_tools = manager._create_prefixed_tools([t1, t2], server, add_prefix=False) - - # Returned names should be unprefixed - names = sorted([t.name for t in out_tools]) - assert names == ["close_issue", "create_issue"] - - # Mapping should include both original and prefixed names -> resolves calls either way - assert manager.tool_name_to_mcp_server_name_mapping["create_issue"] == "jira" - assert ( - manager.tool_name_to_mcp_server_name_mapping["jira-create_issue"] == "jira" - ) - assert manager.tool_name_to_mcp_server_name_mapping["close_issue"] == "jira" - assert ( - manager.tool_name_to_mcp_server_name_mapping["jira-close_issue"] == "jira" - ) - - def test_get_mcp_server_from_tool_name_with_prefixed_and_unprefixed(self): - """After mapping is populated, manager resolves both prefixed and unprefixed tool names to the same server.""" - manager = MCPServerManager() - - server = MCPServer( - server_id="zapier", - name="zapier", - server_name="zapier", - transport=MCPTransport.http, - ) - - # Register server so resolution can find it - manager.registry = {server.server_id: server} - - # Populate mapping (add_prefix value doesn't matter for mapping population) - base_tool = MagicMock() - base_tool.name = "create_zap" - base_tool.description = "" - base_tool.inputSchema = {} - _ = manager._create_prefixed_tools([base_tool], server, add_prefix=False) - - # Unprefixed resolution - resolved_server_unpref = manager._get_mcp_server_from_tool_name("create_zap") - print(resolved_server_unpref) - assert resolved_server_unpref is not None - assert resolved_server_unpref.server_id == server.server_id - - # Prefixed resolution - resolved_server_pref = manager._get_mcp_server_from_tool_name( - "zapier-create_zap" - ) - assert resolved_server_pref is not None - assert resolved_server_pref.server_id == server.server_id - if __name__ == "__main__": pytest.main([__file__]) From 45f835227bca3da92f4ccff3dcf7492b86d3f171 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:14:58 -0700 Subject: [PATCH 35/65] Revert "Merge pull request #14769 from TeddyAmkie/doc-updates-sept-2025" This reverts commit 666bcac2af115cd87c71ad5018fca46e91aa7c99, reversing changes made to b7803bcbb008ceb0bd6a678044104207b6d41ccc. --- docs/my-website/docs/completion/usage.md | 1 - docs/my-website/docs/enterprise.md | 5 - docs/my-website/docs/fine_tuning.md | 2 - docs/my-website/docs/getting_started.md | 3 +- docs/my-website/docs/image_edits.md | 3 - docs/my-website/docs/image_generation.md | 2 - docs/my-website/docs/index.md | 9 - docs/my-website/docs/moderation.md | 2 - .../docs/observability/callbacks.md | 21 +- .../docs/observability/custom_callback.md | 17 - docs/my-website/docs/providers/bedrock.md | 33 -- docs/my-website/docs/providers/vertex.md | 14 +- docs/my-website/docs/proxy/caching.md | 14 - docs/my-website/docs/proxy/config_settings.md | 1 - docs/my-website/docs/proxy/custom_sso.md | 4 +- docs/my-website/docs/proxy/db_deadlocks.md | 26 -- .../docs/proxy/guardrails/bedrock.md | 4 - docs/my-website/docs/proxy/load_balancing.md | 3 - docs/my-website/docs/proxy/self_serve.md | 6 +- docs/my-website/docs/proxy_api.md | 2 +- docs/my-website/docs/rerank.md | 2 - docs/my-website/docs/response_api.md | 40 -- .../img/default_user_settings_admin_ui.png | Bin 239138 -> 0 bytes docs/my-website/sidebars.js | 349 ++++++++---------- .../model_armor/model_armor.py | 159 +++++--- security.md | 5 - 26 files changed, 283 insertions(+), 444 deletions(-) delete mode 100644 docs/my-website/img/default_user_settings_admin_ui.png diff --git a/docs/my-website/docs/completion/usage.md b/docs/my-website/docs/completion/usage.md index c388e5bfee1..2a9eab941ea 100644 --- a/docs/my-website/docs/completion/usage.md +++ b/docs/my-website/docs/completion/usage.md @@ -26,7 +26,6 @@ response = completion( print(response.usage) ``` -> **Note:** LiteLLM supports endpoint bridgingā€”if a model does not natively support a requested endpoint, LiteLLM will automatically route the call to the correct supported endpoint (such as bridging `/chat/completions` to `/responses` or vice versa) based on the model's `mode`set in `model_prices_and_context_window`. ## Streaming Usage diff --git a/docs/my-website/docs/enterprise.md b/docs/my-website/docs/enterprise.md index cc3466fc103..9101d8e3751 100644 --- a/docs/my-website/docs/enterprise.md +++ b/docs/my-website/docs/enterprise.md @@ -1,11 +1,6 @@ import Image from '@theme/IdealImage'; # Enterprise - -:::info -āœØ SSO is free for up to 5 users. After that, an enterprise license is required. [Get Started with Enterprise here](https://www.litellm.ai/enterprise) -::: - For companies that need SSO, user management and professional support for LiteLLM Proxy :::info diff --git a/docs/my-website/docs/fine_tuning.md b/docs/my-website/docs/fine_tuning.md index f3f955cb01d..f9a9297e062 100644 --- a/docs/my-website/docs/fine_tuning.md +++ b/docs/my-website/docs/fine_tuning.md @@ -13,8 +13,6 @@ This is an Enterprise only endpoint [Get Started with Enterprise here](https://c | Feature | Supported | Notes | |-------|-------|-------| | Supported Providers | OpenAI, Azure OpenAI, Vertex AI | - | - -#### āš”ļøSee an exhaustive list of supported models and providers at [models.litellm.ai](https://models.litellm.ai/) | Cost Tracking | šŸŸ” | [Let us know if you need this](https://github.com/BerriAI/litellm/issues) | | Logging | āœ… | Works across all logging integrations | diff --git a/docs/my-website/docs/getting_started.md b/docs/my-website/docs/getting_started.md index 6b2c1fd531e..15ee00a7273 100644 --- a/docs/my-website/docs/getting_started.md +++ b/docs/my-website/docs/getting_started.md @@ -32,8 +32,7 @@ Next Steps šŸ‘‰ [Call all supported models - e.g. Claude-2, Llama2-70b, etc.](./ More details šŸ‘‰ - [Completion() function details](./completion/) -- [Overview of supported models / providers on LiteLLM](./providers/) -- [Search all models / providers](https://models.litellm.ai/) +- [All supported models / providers on LiteLLM](./providers/) - [Build your own OpenAI proxy](https://github.com/BerriAI/liteLLM-proxy/tree/main) ## streaming diff --git a/docs/my-website/docs/image_edits.md b/docs/my-website/docs/image_edits.md index 84dddd5e4ad..246e1c70f0e 100644 --- a/docs/my-website/docs/image_edits.md +++ b/docs/my-website/docs/image_edits.md @@ -18,9 +18,6 @@ LiteLLM provides image editing functionality that maps to OpenAI's `/images/edit | Supported LiteLLM Proxy Versions | 1.71.1+ | | | Supported LLM providers | **OpenAI** | Currently only `openai` is supported | - #### āš”ļøSee all supported models and providers at [models.litellm.ai](https://models.litellm.ai/) - - ## Usage ### LiteLLM Python SDK diff --git a/docs/my-website/docs/image_generation.md b/docs/my-website/docs/image_generation.md index 8cd5803aa6c..7e7ff9922d6 100644 --- a/docs/my-website/docs/image_generation.md +++ b/docs/my-website/docs/image_generation.md @@ -279,8 +279,6 @@ print(f"response: {response}") ## Supported Providers -#### āš”ļøSee all supported models and providers at [models.litellm.ai](https://models.litellm.ai/) - | Provider | Documentation Link | |----------|-------------------| | OpenAI | [OpenAI Image Generation ā†’](./providers/openai) | diff --git a/docs/my-website/docs/index.md b/docs/my-website/docs/index.md index 11d2963b7a3..3f5e1b479c3 100644 --- a/docs/my-website/docs/index.md +++ b/docs/my-website/docs/index.md @@ -524,15 +524,6 @@ try: except OpenAIError as e: print(e) ``` -### See How LiteLLM Transforms Your Requests - -Want to understand how LiteLLM parses and normalizes your LLM API requests? Use the `/utils/transform_request` endpoint to see exactly how your request is transformed internally. - -You can try it out now directly on our Demo App! -Go to the [LiteLLM API docs for transform_request](https://litellm-api.up.railway.app/#/llm%20utils/transform_request_utils_transform_request_post) - -LiteLLM will show you the normalized, provider-agnostic version of your request. This is useful for debugging, learning, and understanding how LiteLLM handles different providers and options. - ### Logging Observability - Log LLM Input/Output ([Docs](https://docs.litellm.ai/docs/observability/callbacks)) LiteLLM exposes pre defined callbacks to send data to Lunary, MLflow, Langfuse, Helicone, Promptlayer, Traceloop, Slack diff --git a/docs/my-website/docs/moderation.md b/docs/my-website/docs/moderation.md index f9c2810bc8a..95fe8b2856d 100644 --- a/docs/my-website/docs/moderation.md +++ b/docs/my-website/docs/moderation.md @@ -130,8 +130,6 @@ Here's the exact json output and type you can expect from all moderation calls: ## **Supported Providers** -#### āš”ļøSee all supported models and providers at [models.litellm.ai](https://models.litellm.ai/) - | Provider | |-------------| | OpenAI | diff --git a/docs/my-website/docs/observability/callbacks.md b/docs/my-website/docs/observability/callbacks.md index b752bdc2764..040d83697d3 100644 --- a/docs/my-website/docs/observability/callbacks.md +++ b/docs/my-website/docs/observability/callbacks.md @@ -5,15 +5,13 @@ liteLLM provides `input_callbacks`, `success_callbacks` and `failure_callbacks`, making it easy for you to send data to a particular provider depending on the status of your responses. :::tip -**New to LiteLLM Callbacks?** - -- For proxy/server logging and observability, see the [Proxy Logging Guide](https://docs.litellm.ai/docs/proxy/logging). -- To write your own callback logic, see the [Custom Callbacks Guide](https://docs.litellm.ai/docs/observability/custom_callback). +**New to LiteLLM Callbacks?** Check out our comprehensive [Callback Management Guide](./callback_management.md) to understand when to use different callback hooks like `async_log_success_event` vs `async_post_call_success_hook`. ::: +liteLLM supports: -### Supported Callback Integrations - +- [Custom Callback Functions](https://docs.litellm.ai/docs/observability/custom_callback) +- [Callback Management Guide](./callback_management.md) - **Comprehensive guide for choosing the right hooks** - [Lunary](https://lunary.ai/docs) - [Langfuse](https://langfuse.com/docs) - [LangSmith](https://www.langchain.com/langsmith) @@ -23,20 +21,9 @@ liteLLM provides `input_callbacks`, `success_callbacks` and `failure_callbacks`, - [Sentry](https://docs.sentry.io/platforms/python/) - [PostHog](https://posthog.com/docs/libraries/python) - [Slack](https://slack.dev/bolt-python/concepts) -- [Arize](https://docs.arize.com/) -- [PromptLayer](https://docs.promptlayer.com/) This is **not** an extensive list. Please check the dropdown for all logging integrations. -### Related Cookbooks -Try out our cookbooks for code snippets and interactive demos: - -- [Langfuse Callback Example (Colab)](https://colab.research.google.com/github/BerriAI/litellm/blob/main/cookbook/logging_observability/LiteLLM_Langfuse.ipynb) -- [Lunary Callback Example (Colab)](https://colab.research.google.com/github/BerriAI/litellm/blob/main/cookbook/logging_observability/LiteLLM_Lunary.ipynb) -- [Arize Callback Example (Colab)](https://colab.research.google.com/github/BerriAI/litellm/blob/main/cookbook/logging_observability/LiteLLM_Arize.ipynb) -- [Proxy + Langfuse Callback Example (Colab)](https://colab.research.google.com/github/BerriAI/litellm/blob/main/cookbook/logging_observability/LiteLLM_Proxy_Langfuse.ipynb) -- [PromptLayer Callback Example (Colab)](https://colab.research.google.com/github/BerriAI/litellm/blob/main/cookbook/LiteLLM_PromptLayer.ipynb) - ### Quick Start ```python diff --git a/docs/my-website/docs/observability/custom_callback.md b/docs/my-website/docs/observability/custom_callback.md index cfe97ca42c0..c206c23d0f4 100644 --- a/docs/my-website/docs/observability/custom_callback.md +++ b/docs/my-website/docs/observability/custom_callback.md @@ -67,23 +67,6 @@ asyncio.run(completion()) - `async_post_call_success_hook` - Access user data + modify responses - `async_pre_call_hook` - Modify requests before sending -### Example: Modifying the Response in async_post_call_success_hook - -You can use `async_post_call_success_hook` to add custom headers or metadata to the response before it is returned to the client. For example: - -```python -async def async_post_call_success_hook(data, user_api_key_dict, response): - # Add a custom header to the response - additional_headers = getattr(response, "_hidden_params", {}).get("additional_headers", {}) or {} - additional_headers["x-litellm-custom-header"] = "my-value" - if not hasattr(response, "_hidden_params"): - response._hidden_params = {} - response._hidden_params["additional_headers"] = additional_headers - return response -``` - -This allows you to inject custom metadata or headers into the response for downstream consumers. You can use this pattern to pass information to clients, proxies, or observability tools. - ## Callback Functions If you just want to log on a specific event (e.g. on input) - you can use callback functions. diff --git a/docs/my-website/docs/providers/bedrock.md b/docs/my-website/docs/providers/bedrock.md index fe996099145..86e9ac5e3e6 100644 --- a/docs/my-website/docs/providers/bedrock.md +++ b/docs/my-website/docs/providers/bedrock.md @@ -2340,39 +2340,6 @@ response = completion( Make the bedrock completion call ---- - -### Required AWS IAM Policy for AssumeRole - -To use `aws_role_name` (STS AssumeRole) with LiteLLM, your IAM user or role **must** have permission to call `sts:AssumeRole` on the target role. If you see an error like: - -``` -An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:sts::...:assumed-role/litellm-ecs-task-role/... is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::...:role/Enterprise/BedrockCrossAccountConsumer -``` - -This means the IAM identity running LiteLLM does **not** have permission to assume the target role. You must update your IAM policy to allow this action. - -#### Example IAM Policy - -Replace `` with the ARN of the role you want to assume (e.g., `arn:aws:iam::123456789012:role/Enterprise/BedrockCrossAccountConsumer`). - -```json -{ - "Version": "2012-10-17", - "Statement": [ - { - "Effect": "Allow", - "Action": "sts:AssumeRole", - "Resource": "" - } - ] -} -``` - -**Note:** The target role itself must also trust the calling IAM identity (via its trust policy) for AssumeRole to succeed. See [AWS AssumeRole docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-api.html) for more details. - ---- - diff --git a/docs/my-website/docs/providers/vertex.md b/docs/my-website/docs/providers/vertex.md index 260cc55c2e9..ef407e6c102 100644 --- a/docs/my-website/docs/providers/vertex.md +++ b/docs/my-website/docs/providers/vertex.md @@ -196,19 +196,7 @@ model_list: vertex_location: "us-central1" vertex_credentials: "/path/to/service_account.json" # [OPTIONAL] Do this OR `!gcloud auth application-default login` - run this to add vertex credentials to your env ``` -or -```yaml -model_list: - - model_name: gemini-pro - litellm_params: - model: vertex_ai/gemini-1.5-pro - litellm_credential_name: vertex-global - vertex_project: project-name-here - vertex_location: global - base_model: gemini - model_info: - provider: Vertex -``` + 2. Start Proxy ``` diff --git a/docs/my-website/docs/proxy/caching.md b/docs/my-website/docs/proxy/caching.md index 617609cf08a..1fb7385f689 100644 --- a/docs/my-website/docs/proxy/caching.md +++ b/docs/my-website/docs/proxy/caching.md @@ -958,19 +958,6 @@ curl http://localhost:4000/v1/chat/completions \ - -## Redis max_connections - -You can set the `max_connections` parameter in your `cache_params` for Redis. This is passed directly to the Redis client and controls the maximum number of simultaneous connections in the pool. If you see errors like `No connection available`, try increasing this value: - -```yaml -litellm_settings: - cache: true - cache_params: - type: redis - max_connections: 100 -``` - ## Supported `cache_params` on proxy config.yaml ```yaml @@ -979,7 +966,6 @@ cache_params: ttl: Optional[float] default_in_memory_ttl: Optional[float] default_in_redis_ttl: Optional[float] - max_connections: Optional[Int] # Type of cache (options: "local", "redis", "s3") type: s3 diff --git a/docs/my-website/docs/proxy/config_settings.md b/docs/my-website/docs/proxy/config_settings.md index f70701886b5..974e95a07bd 100644 --- a/docs/my-website/docs/proxy/config_settings.md +++ b/docs/my-website/docs/proxy/config_settings.md @@ -50,7 +50,6 @@ litellm_settings: port: 6379 # The port number for the Redis cache. Required if type is "redis". password: "your_password" # The password for the Redis cache. Required if type is "redis". namespace: "litellm.caching.caching" # namespace for redis cache - max_connections: 100 # [OPTIONAL] Set Maximum number of Redis connections. Passed directly to redis-py. # Optional - Redis Cluster Settings redis_startup_nodes: [{"host": "127.0.0.1", "port": "7001"}] diff --git a/docs/my-website/docs/proxy/custom_sso.md b/docs/my-website/docs/proxy/custom_sso.md index bbd7f41bee1..8e869a11393 100644 --- a/docs/my-website/docs/proxy/custom_sso.md +++ b/docs/my-website/docs/proxy/custom_sso.md @@ -1,7 +1,9 @@ # āœØ Event Hooks for SSO Login :::info -āœØ SSO is free for up to 5 users. After that, an enterprise license is required. [Get Started with Enterprise here](https://www.litellm.ai/enterprise) + +āœØ This is an Enterprise only feature [Get Started with Enterprise here](https://www.litellm.ai/enterprise) + ::: ## Overview diff --git a/docs/my-website/docs/proxy/db_deadlocks.md b/docs/my-website/docs/proxy/db_deadlocks.md index ef9d31d6232..0eee928fa64 100644 --- a/docs/my-website/docs/proxy/db_deadlocks.md +++ b/docs/my-website/docs/proxy/db_deadlocks.md @@ -84,29 +84,3 @@ LiteLLM emits the following prometheus metrics to monitor the health/status of t | `litellm_in_memory_spend_update_queue_size` | In-memory aggregate spend values for keys, users, teams, team members, etc.| In-Memory | | `litellm_redis_spend_update_queue_size` | Redis aggregate spend values for keys, users, teams, etc. | Redis | - -## Troubleshooting: Redis Connection Errors - -You may see errors like: - -``` -LiteLLM Redis Caching: async async_increment() - Got exception from REDIS No connection available., Writing value=21 -LiteLLM Redis Caching: async set_cache_pipeline() - Got exception from REDIS No connection available., Writing value=None -``` - -This means all available Redis connections are in use, and LiteLLM cannot obtain a new connection from the pool. This can happen under high load or with many concurrent proxy requests. - -**Solution:** - -- Increase the `max_connections` parameter in your Redis config section in `proxy_config.yaml` to allow more simultaneous connections. For example: - -```yaml -litellm_settings: - cache: True - cache_params: - type: redis - max_connections: 100 # Increase as needed for your traffic -``` - -Adjust this value based on your expected concurrency and Redis server capacity. - diff --git a/docs/my-website/docs/proxy/guardrails/bedrock.md b/docs/my-website/docs/proxy/guardrails/bedrock.md index 4a1a0a246f8..6725acf1f25 100644 --- a/docs/my-website/docs/proxy/guardrails/bedrock.md +++ b/docs/my-website/docs/proxy/guardrails/bedrock.md @@ -4,10 +4,6 @@ import TabItem from '@theme/TabItem'; # Bedrock Guardrails -:::tip āš”ļø -If you haven't set up or authenticated your Bedrock provider yet, see the [Bedrock Provider Setup & Authentication Guide](../../providers/bedrock.md). -::: - LiteLLM supports Bedrock guardrails via the [Bedrock ApplyGuardrail API](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ApplyGuardrail.html). ## Quick Start diff --git a/docs/my-website/docs/proxy/load_balancing.md b/docs/my-website/docs/proxy/load_balancing.md index 54c917bbbca..bcbc4e93651 100644 --- a/docs/my-website/docs/proxy/load_balancing.md +++ b/docs/my-website/docs/proxy/load_balancing.md @@ -172,9 +172,6 @@ router_settings: redis_host: redis_password: redis_port: 1992 - cache_params: - type: redis - max_connections: 100 # maximum Redis connections in the pool; tune based on expected concurrency/load ``` ## Router settings on config - routing_strategy, model_group_alias diff --git a/docs/my-website/docs/proxy/self_serve.md b/docs/my-website/docs/proxy/self_serve.md index b54344c1d05..dff55a8ac04 100644 --- a/docs/my-website/docs/proxy/self_serve.md +++ b/docs/my-website/docs/proxy/self_serve.md @@ -227,7 +227,7 @@ export PROXY_LOGOUT_URL="https://www.google.com" -### Set default max budget for internal users +### Set max budget for internal users Automatically apply budget per internal user when they sign up. By default the table will be checked every 10 minutes, for users to reset. To modify this, [see this](./users.md#reset-budgets) @@ -239,10 +239,6 @@ litellm_settings: This sets a max budget of $10 USD for internal users when they sign up. -You can also manage these settings visually in the UI: - - - This budget only applies to personal keys created by that user - seen under `Default Team` on the UI. diff --git a/docs/my-website/docs/proxy_api.md b/docs/my-website/docs/proxy_api.md index 7612645fb54..89bfacbe19f 100644 --- a/docs/my-website/docs/proxy_api.md +++ b/docs/my-website/docs/proxy_api.md @@ -27,7 +27,7 @@ Email us @ krrish@berri.ai ## Supported Models for LiteLLM Key These are the models that currently work with the "sk-litellm-.." keys. -For a complete list of models/providers that you can call with LiteLLM, [check out our provider list](./providers/) or check out [models.litellm.ai](https://models.litellm.ai/) +For a complete list of models/providers that you can call with LiteLLM, [check out our provider list](./providers/) * OpenAI models - [OpenAI docs](./providers/openai.md) * gpt-4 diff --git a/docs/my-website/docs/rerank.md b/docs/my-website/docs/rerank.md index cad64718384..c57eacbb224 100644 --- a/docs/my-website/docs/rerank.md +++ b/docs/my-website/docs/rerank.md @@ -109,8 +109,6 @@ curl http://0.0.0.0:4000/rerank \ ## **Supported Providers** -#### āš”ļøSee all supported models and providers at [models.litellm.ai](https://models.litellm.ai/) - | Provider | Link to Usage | |-------------|--------------------| | Cohere (v1 + v2 clients) | [Usage](#quick-start) | diff --git a/docs/my-website/docs/response_api.md b/docs/my-website/docs/response_api.md index b03e4f8be92..94d7c73be05 100644 --- a/docs/my-website/docs/response_api.md +++ b/docs/my-website/docs/response_api.md @@ -3,11 +3,8 @@ import TabItem from '@theme/TabItem'; # /responses [Beta] - LiteLLM provides a BETA endpoint in the spec of [OpenAI's `/responses` API](https://platform.openai.com/docs/api-reference/responses) -Requests to /chat/completions may be bridged here automatically when the provider lacks support for that endpoint. The modelā€™s default `mode` determines how bridging works.(see `model_prices_and_context_window`) - | Feature | Supported | Notes | |---------|-----------|--------| | Cost Tracking | āœ… | Works with all supported models | @@ -81,43 +78,6 @@ print(retrieved_response) # retrieved_response = await litellm.aget_responses(response_id=response_id) ``` -#### CANCEL a Response -You can cancel an in-progress response (if supported by the provider): - -```python showLineNumbers title="Cancel Response by ID" -import litellm - -# First, create a response -response = litellm.responses( - model="openai/o1-pro", - input="Tell me a three sentence bedtime story about a unicorn.", - max_output_tokens=100 -) - -# Get the response ID -response_id = response.id - -# Cancel the response by ID -cancel_response = litellm.cancel_responses( - response_id=response_id -) - -print(cancel_response) - -# For async usage -# cancel_response = await litellm.acancel_responses(response_id=response_id) -``` - - -**REST API:** -```bash -curl -X POST http://localhost:4000/v1/responses/response_id/cancel \ - -H "Authorization: Bearer sk-1234" -``` - -This will attempt to cancel the in-progress response with the given ID. -**Note:** Not all providers support response cancellation. If unsupported, an error will be raised. - #### DELETE a Response ```python showLineNumbers title="Delete Response by ID" import litellm diff --git a/docs/my-website/img/default_user_settings_admin_ui.png b/docs/my-website/img/default_user_settings_admin_ui.png deleted file mode 100644 index 5910154cd51f4914fc7db293183e6fa39a264920..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 239138 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

3Y|kZ*?uZg2 zOS|3#>vmm5P9(4S+v*ldyUmv=}L%_H1 z$R$;5nmR=K9>}K(tDY#2(vMs}90LXJ%hHvmDdk8BpWI-#631@~i32P?*@E z%^!&LK$?D=?2nIq1a0CV)q5$68=!4&!&g2CQh3E^4{uBsTQ}dl`>obl@v(y7qyq}f zEB|TarRS)LL}KT>Nw0}L<74@jn3TlsJbm(6@7k*@_D!o?EHiS!ZE^1tjFX)x06E>R z^Rt|AehIv>dbJZ$pvDK8q9Z}9s_QA$VNY&m5(aulW-qC#l zhp%UkF^YX&I&mQUdV|`z>+c8 zdR%UoI`vjz2p59>);l06S|1fH^JVIZ-w~aGG-G%Zd3BtFF&&p+{-g42ERouNT zPmstyVp)9+-&;GDsVNDEVtVs~3#pf>4M7k2+S!=tPHIkeR(D>0b|(gB1(2BE1}A5< zybufnqcxt<)j_f?u}3lT=I@!=rwo~e+}PB812n%VXFVAn9#r1wSvl9 zO3uL~T+R4`POE(iHF_Swd>N?I+1BKRFUGoIGDIvdPb$E%hP%Bt#(OUW4GP6B68BPMwkAP1n22^+4K$ zLG)$x2=vyWj=N@B0{nqHiG1tPZ`HdArCD()|rl2G22ekcTh{#$Iwd-N3ol@Rn8VrwvI}+`6?3x3$wn6JELv<-@3m?>#IEyl3 zOtr{x{wsL_3fq|ViIk*#Ep$lT?o`$pclUK(>xX>Ex?iGJ%h~Shc0~3;@1+iqtszbi zvH}C9NWwFPnDfwworUTXS-IcH+~TR*JdhuI=L?)gw`*j|GK1!eB{Vyyz0tJOsI72s zMKVH)cgzo09nCtKT$a_92OGNMd7>o7%frZq^4bRsS>|`E_126gY7!hv6M(nk`af8! ze`xye>0)2-s8)6SaH$tvDvgX;Ki%FZO9yCqURHCr_sA(_d84hgCq821sq%A%g9~r; z1vjF#wru`%nsOqS#ONe8iqtlLLCPIeZdxk}=2-gfi7+UQ0oQP~dY|ke58q+b^htlN zzd$zv*~zsqBFbeLU+oBA)J;wjRR_2$OAe1Pb`CEpil`yeARdp=5<_1K=a(LR_d49V zS_*0xR^6{&CesPoOK?aw-=6$n;LSRMcI2veIb>klX|j&x{8KH)!$#R_F2C9=>#jni z!a_HkN3~*7#Fu>IIi?a<%(MYAZJiMjs?~^8h6N;#IW3gHCz)tj2Nq^C7(2ns^3_X|7mkNZ|e24Z(`GHb+GB<@w7>n?eGS_A98ZePBWO^rD|N& zG{GR3$E{$^&$u1!C@`rN8Ou@6gg#jn^cHq_P@>IGDwGmEnER$_I&uQy4SgFbbhO@y z$y(u&5AqB>u-;-(@Ly}<{dbgf8A}`EZd2?ynDy?PB$Lf6*Yz8l`!%QwYusz#f#jH;l;7bi{;h2`ej`GtX|71F^Wj&mPI#eDS|xg zhjhKz%g5t0slhdEa{BaW~-W^i{vl0+b44_!xN~mb}x=qK9pm!&U8K)$0S*2X76s~1`E5r*0a_aOb!v|QSmx8 z{jyP{B1;YO&ZF@PxUmuF+p3Fz3TZzTjTWGr}vel##Ll9lH4yKRoR%fQy9+A@BizV)~{ zp?2a>$EibK7$Fk*CqpIA#q>3oZm#-0t)U|2YoR_N*O~W;jJCGIY?(51-_fi;oeSPk ze!`NT7EM@D-P%Q_ts8dr+QYJaoimM050rT(>*LwpAKqBk#qg&@bz8LWWWOcV+_w2C zc?X-@cq=J9DIawiN7+m9PFEckemyR{*s!uoD}hP0kQ?2_Q!{igPxV`PfRzmAS?DyW zHHF9>8%$iv-5~?eum^5XbllI0#cnM+7^_C1YQMsMe1`YyG>eI@y>8HU5b@~~*4?^1 z+6B1hg@=F zi#MOFhjzkXj*bd*tg-lo0#Q*+0)d3xAzPfy5+00)b*FA06uT_1@xhVd?D5`KEInKL zw%75KT|{-JVu-Ud9pEcp?1n>e*yRg5-C0}?gK(DMJhTMN7D_5tt=lu1Rkju^;U!w^ z$t2k~U&k~y#Z$?J@}RMN1Du^?!)P_vnIuR&+`KK}(Aow6lPe>sDi5JTj{-B&_}#u% zpYiX?(>*sPTVyzf1fdz1+@?ZmD{{ zj{%DCB-SC8>sk8^dPz*Q$@o~uX5c93xJF8rdH(?#SeVW#PD4M-@ttOHF`&5O_2ZKEO!sXVj0&t3t{NK z*IeXHS~YzCq^0w>d8wQ;>1sqdoR>R?=xS3C*Q%fDk<}X-3c)^AUZGsa8D02lBr=XE zB7QUW*_h~dl3$P!vl)OYz_>?%x%UUPjg>{-O2kc}r4FJ$r#VS*`#RHKp&|9;HX=WC zd?y{8_J%qpZC|t3V!XKCq#6A&)NPxk3xqK@BJTST-W9rqhi9fHQDC#I#@E$(6^D|A zW45_2fg!6wl2T~hI+NYbCn`~FbmPzaj`km|*Y)P~$elYsFeopGs_-aj=>vd&;RIWy2x0cy?Dx(h zPsOdEG*2u{l=6r~(9$#x*`AQ;Cz;R@sa`xKlh^U&O31gnNdCZ||=1Kftbk>9i7dB~Wgb zymOB=@X78@@mB$tY@$mL!W7=bG~|56Hg7~0?3%_CqK$Gkp2pvo=~I?@@NB89m``|e z?{b*)ZBz`M@LJ$t9dmCTSU?S!Dj8%eLF369A0lck)5s4EvOD4e72l$Fq-}S0SLIaj zo=6M~Tph_qzKUs-ptKIOJv9hPFI;oz-MIboJ8uhfyTNtuBVm>M`E3z~^oL74_1FbY z%L+L4z|gJi+6;S|EVR&SK59F2oO|9B&LwYSyF%^rqqQbU!XtB$btvuY^E6SWwNu5*Ry^`43RzS%GqBDV`QL;QtN(_ z)vzw{6Z5HkG%m{xL>Go4eLezihT*SYx305mMlz9!?8T{{lE3$Lbx#lSd?LTdfuow^ zz87VXqs7LO?X<*|vjgi8J6?0V>)$mV?r2E%ymqTljHawUNBL>K`@!0omuqI-v0;s9 z6cr_?G+B~~cq}$?zu8q(Ul4;Qy)CsSTdn;qXR1@6yrovR19h;Mqj^qjB_}*(?q@4n z)Z6(zdMWcng?Vk1?DM*pwr_&7DnGxo>d&<11|PGJQ`Jz-Fs3=(TS9Z>y)qH7F4TNh zy?Lhe@Ja-q6&~+S%K-ByV`|c3<;s^Eg1d55u7dJsXM8Rc!VNlQAlJM8`*S2#<;FOh zqW5=pYPPoTeKslBR7FDkuLLM!Q1ktV?jw1T>Q-xl5I2am6Zh z+*{CjLM%aHTC2<~VKASt+B)M&pxX&ZRc~Ho=9{p~5<@3AV zdPTZWx1qV`S3_L;mER}6bCv3_67;lJ=%w3h;3mjcd27w9LKCg{EgVEwkNBUIYc!6a zpFEI7X=qJf+YRv-6USICEC3AJlmFv#p$}oS@`1x;1Q$xxg$6qUxG~qABQ{C4 z9s$%Qf++nW0Gkg#r-&J!G&TWHOL(DC$8?&B)s~I5LZ$XS{HJV1XacNNzp0M&Q+71l1x& zbAa_uz-82Mo?S1WF-yz|ggn3a{G*Y*o#%LKu~|%f`jk+JH39kM)jvxnn5s(3A(o8X zR&jRI2dlP{>|QmGka#W(9;_MDviug{iw>v6doWPIe><&yv;;5!NvoE8agMkBd<{T4 ze6ql8?oYiayhsTLbRuDplr(M>Uoj6PfPkv(C8EZrY&}wei}gHy13UDs|9X=lX1{;P zgV90tki?9auPpqLG*hK<$qoVWDvpbO_45m-CGt83a}KmC#pK${AxLab*aJalwwVPS;bg6*R*Cy+qplOdvB@vWI z(&^F2bXaIC6At|$kKv!iP0%MxSC7`e9#zaGI#03!SV$)-g=9Tdzel`jvqEDS zz;3F`&7(=`I{rX2(4PB=T^=j)?himk%ZFmBP<~r)P`AMsvNqiL+npL>EWDrbets}K zWUN!;=L%3y+&6DgiM(>!kO|F{KM0R^*L_819qRs{5nnWmz!J7h($4x~Y`_4WQu?!m zh_4(vNY(GPAbHaSAbjHYQ9I_(AL5;=6>7f%m5d^XGbrtk=F9SdbvrZByU=LTG9%;K z%oB!?whBvY>lpoKCVFv?<0?{}_o6_md~-vVF=BUPvRW2$fPndZXd^h6=Gkk^^nt1h?*z0ovhuIv>)`4XzOtmQ zK5Ajfa4H~6t-Wc93QoO?0gE}+(bI2@Znsq^m%VW0FP4No6O{70-ofT_xU~mP2h0^+ z-lf8?V3)R&|8(hK-yi<=^XP-Axq=92-gizfP9<&t`-Mic3<><`H#k}10(R9r(4yI z;Hy&@ua$SCstaaZ!;Sbcqt9@6D^K}HDSmO&Cp0gr_DvL<9-XO?j8Ty((eHSxD($%V z)c`;Eq?mSON2I}e+nJwd;FTauGI9O)b;FGsyaNiA?!mt87Uui$YjVv^ZHh0UXjyNa z2e#X`04DYazu`s0K-z=~IG2DeGdH&4c;BpZ=8TUB?#IaqdhMCFR>={ukN1TpilT9@ zRGPVp6}H|}yAC24y3VTqtW3|-gk$~~jPIo@NB8=w^c^!_-_FyB@(pOh-pA2uSIUd@ zgw7bd&NlO%UU~D};X0K7rvcO-`yD~mPztH@?gDOq z;2O1THO&qXw50>83HkO@{zs$Wqm1b@iV#+^!t@z2T3yDYRA-@P_=3~yNmt_P1#lm| zhOo?TP+o2V2)aP{=w{!?`CKYuL&qC$lxw|t&sac5zceQ&XNFPts&bZ-y!6Yqvr<#Z z=JImxHxRcVAt98j-~gz1eCJXS>|tm4&F~W7pxQ{U$|YH@fMp<7jh@@V&0hbvCt)NXn;=;>~)3=g}~!R%LT7M}+N z={bn-onw~@-dj(V0u*kpNph+dDU6&;GJL77G2F3dQIXQ1dkJV;}F{K-lYxZs_B>wee;rW@N^z7 znl@=_#_Mv;)0l2`TV!xqt~N9>=%C>mD&?D zw|Tl8mvy#K0qWR6}pmkQ%@0ji1o)BI$o*eLdCHV21lo|+X2C^t(WqoP<*@>CvsZ@gjiwjb%*KkYu7a290^ z8!>{iXjNF@j{lhTS5a7H%}N;MH#up7C5P)pvEq*}7Oty6N+)^hlA+Q~jP_GUuSJe5 zlJE`=1-qWnsrYUGo5n{rvF)um{@}K*@UGGkpO``~2QRuTSuiykz|UT10*NTn=xQAC1@;c+;Z z!I*X4hAmQ_Y%_osE;cQ_=xJ&0TL+$5O0B)GkdZ1V>|FIT=b+!*Weu)4Kc@)YV+nI> z9nP)@(ROHzO@op`LdHEYhOs(J#rN1x>*(Ob zZ)b0}$bVwNy4HK=hW8udJ&`&@IkLf>l6%={?^Qr&wQ+LT(n_ZURE5lB(6|DQl{Pti z@O^k-|4$jM|H;m-=Q5v3J|3aeu_qTg{@So^QTpyHskY|DH-5ZG=eep^S1k_t$`zO0 z#Jzi0Typ3yq3Uw%PUe0!k4;(Ph3MEfH}k$FceB#z4T+?3o|aHNo{n^v%UjeUPL#EKfP%dD!t^#`#5u2XI-v@JwUl&TUbZ?E{ud!P+ZS6E=pkA|f zYT`M20TSpA@8z$FTav|*i>~O888DYG3elGGL{aYzH0U0t`Q`{Y1GJt#J{mL( zaQ1vF+K5RHiTK(h*n|;)7~OvCO_? zWFuzLx}dOr?MVk>8rqn-lTGZqSJ;jkOgZDHCs>A@o>C%%htP!%2vkTXv&t)OWx*QQ zET{Du5`?suOa6=V@etE4{Ji)UCXA0D^4T%+{~h>6mH*p;>s_HP_WjVD`~!eLo1jc> z6yozprM&$={U(oMbMzo~Lufg%4&3+4+#wscaX+bZucxXcpXoEt*6$qGI;}U|Hl=HI z+%$=H)ExFCA1>?Egm1v{ManwKyad~^=;L@z4YJUuhV7iLh>yJ}`@Id%Ad>~AA|meZ zcY#7iv;{``6n6m(#=M5>I(+x0piW_uJ3zXka-8eUagZzi8FeVlfj zvh^y&Y}V=bU~Dc3;p@Ds_{E?UxVK9v+Ltl6SC?5!F|S$=3h3F$^vK8Fx^-Q;zDc`i z0Z6owQJhjiaF+g^#6Pd&)kSL4r-NQ8*5|@JZ`aw^p*^^@2N!3ejBc)sJDI^Nr_qB& zbt4(u4Fi?EkOQHqkXLiy_?s(K`cnnr@{#O`XRb$qLpz~3tp#Uu91}d;DN)mNb~mYN zPWCc1pC}?Evowd1N_k^`>O)`e3GHnb!S%1V>sxA0n6_)68eZroqZ+6`2mp}a3h>Ky zHBOGkCXaRiYGu^0;AVEObdwU<3KWdVLc%aL(Hb^wZw{tr=N;|g~-6jzWf{WDvMwaE2th*K( zK+SwTewuvS$jz>x?RdXZ^!Rqa?nlb5(;Fy-mBZFpGjldA?(p9k&)@9rDvQ3(X*Kav zDR5YY_Vta)P*~o_OPWT^d!Ak8bK}ntbmP#u zgSWd9P2;*W6DJ~h5;aGO>Cou%u(XM6mu0i!|E$8r`Z0a(ntCrVXFte9iX~LXe{v~N zVPc^BEp6u;^Fb`9ruiY16c5J*o$W$0qkA^N9DCfS;v~reSt+j?A6&wOeM^P+YP|q# z(Bfxn;rh{bc+S~=cFvVd`KveriJAW2>niMqsO>^>A~M(}2SaM$xI-p=W-}YYW%9^1 zf6r$uEN-p$jR3faz6iKADb#YY0=BRF>RmnUj&I>f`{k8pwR&%DYsaF71DqHOw)iY; zsL5UITb)j_A?hx2oZ>8&;J`SzSfYRbCbthHkpAsF4_>}0&vOnB60`MvT;x$?j!71* z(rnG;xfUipkYXip@cD^~^WM{aRz$@>weKtb<_`%qZ zOyyKwye7Q$39bo*O~HKSuhYbVOqIK9NOi4c_xxEkyb}KkUozKTUQuuKo~EwnoG^&y zT@Om#bev<$IbpEcf)wvo2}-Mm)Bp<5Y2$tqxLwIzs_R9E6E~=i@3H>pe6P~{m1=B! z`KRxkL-npP{LRaye7oV2DuH?g5`N2TBWT)mc{N7MAf)-*Oi29{JBLoiGpd+_Z#q_% zzi#oxDM?fXsdkzxK?|q5@ksn|-yKofzwXO*Lt%$Ngf%IOp?eM6GSEumaYh_) zj9!ZKJ`wTB$R_(YDsQN0vz@|&{1YlS<)~O0o$*Q2SN1olf|E~+b1V)kg^d8BDw9l~ zvUdG!)aZ)Z#{;Zf2hDz6`YyHC-33Ox#R$9#&5YmzH9Can432vorlYcePls}dY1cjB z_NM=*$(dPZF2|ku6RNVM-W44%giVFoV*uI%x+D^&TEEaI9Mt0En35Z3k{4P0N*SMu z+4a%O;m~f=I9Wy%+;NuQZi*q>+m92hcdaT;K7i3=D>Sdmo9o^Kpf?KFRq58x>iW1N zlPLyOeP&hf9pcG_gnp}L)NSU9DUELwAzjx#^gD&C8`YV+h*YUB?HY&f@B#Gva?b7VM8O&zvB4Q6T^P>GLK)Y(7mvecXad^wg(X1(-O*9Nyo$?}e zdbh%h^A%uI3;E#^9Q}o&d~=RaJNm|^;^!9U$fk<7?)migzk;QLzQ@+>)~xOma`UTi();Zd`q zz6TB~XnZNGCw_(B&7%rb^J_{^_@w?}iuEvtfOq(q3DlbH@+>tA_eyPRq#)T#BQ$Y*-D?GzrHKmL z`E2DKDcENUPsAaaMysaQxg$0V?Le_atu0~Wi-Mr9PT)k?y{3=Zag%2m5j-K6(jBiW zq`dW*+h#F%`&-VfgPF2yOZ!23QG>2X0t_uo{hy*-JYe$TXse531I;bwmgCA_2)AFMVZ z*O(WHa>$+R>j2D767cNFA4EFu>57M$|#ojMfM3Z=Z8l75IA0*?=4#A6^cWMsJ z)b!dJi=IEZCVCQJ{((VTmJ2rMRuGOe?8tXnut<_zXfRg+x4XO>ynMJC6wL$0N5HWMXXY_WNKMaCCcXc` zHR5)feOWn2SrT0}d4Kq{S{;MIboJ`&Mp-~qM9szeaF<mc-DKaTny?(4` z&HQ+nOHC5OnO31?-JluAWBQ2vY;4}Tlj(8w67NTmn`A-`68f7z0aP&ZqbB6L0_C_& zK^)JdjxvclI2aaHh?UruKfiSRto4S@|1|Mf)E*ta7id4y`Q=S55wbfBpPBvAN=dhr z-*N&MMT;E?aj6V8%Y}o%^ zDUk%755*?`hqJGaigNAVwhIMC5S3D-8>OU`?(UKji2>;x5Ca4Rq#FboI)@lw2oD|7 z%@ESvF)%}X_o(N$&i7mIcV5@`AB#25^W3@jwXePJ`-0y46-M|x0L1n)GUvH^#S`-k zw}D8Lko5;7NiLP+C*Mjk%$DGh&QC`v|E_@Dppf5uy;ixm{o_$r3pl%cG(*J_(ez^~ z**otEac%mDu5%8t?~`teXMVxgE?ga7jsQoX)`zE>0!tt-CX-&u%({m$8-}#L~)}treJSe?b-EF7hE+JW0+-=G%EOs1llO5g_^LZ`A=QE^MH$S{7 z=)NzK2-%U>Iq#d5dX;hM4EO+IpE8mq^WGNK{%W^{q7z2-82=|B6o=xU^`Z+*olbF~ zY?YRNY%%tO%=WJv3=_g`V!_brM4L@^l^9K|yAK18tJdAg%Qte-=8~z+f9~ReM zT_-BgM6(n3;|sPp+cVLSd&@~$7^i;=>hJCCrQs+_NZcQ|0jYSH0Zy7*XB;>-cW3*a z_x-eUUK4k7f~Y(U365xw1b7fLX?zYKZfh4r3)>L1gPOM+eq;{2q4qs)<_FP*JQ+H{ zL}B*z@7*U|@T*2@Yq~$oF=@2-UrsKGAAh5r1}aCyS)nzdap>z#-YZcZG*6#0sAzg) z6I_JKQl8nq(=f6wF%-=*$jf%KA^!d(_l2l`ZH&yv(YlKS)h1kv#f#CfGR#QZfK^q; z{@ij0K8^i66wZINW_%}2I(S{$AjB9H-8u8R}R zvv#6#SJ*hl%r3~Er;yKVB~5z(vg#Ni0rs_fx7!SiMBTso?M0d!x~kWl*rb#j{rJ07 zcq^&dM6rYOY$FYzW)(=mi31mYWvB!Qxt9O~90m^h8NUmY^*WaK;`+-T@iyH6l{i11 zWu2XP$5-9pt=|Nfga_2%R4RGhW8yIL(d;x{=cj(I)qTLyT;yV0oD{C!{I%b`hTdPE z-Pk+T`kGMF1?YbBbMSBoaPLt*l>gBw{6vzg#9)Jae25MIg)493&hj789#y%<%6Y81 zA(fflS$ueGYuOLzSvpE@?ymKA#YTETcEpdVR6{S~L<*hwOOBk5BqSu}L)Db1vW?HU zm<+C9I30k!LHu@{_Yh>$yhRl&O*u zlsi=EJD>Ll8BTi~)IusulCC+H?Z2V-a#f!z$x+}yfw+7m*d3&2OecnfhjI5_kDo_C zP^`&N4#Nqq$eY#aXW0tw$0JyFpCD#{htZ5*s-}}qwDGe7$J(z-8Ibdp=nrM3QO2Dl z)E2NaQ3QkVDNC>XuV6vbZ}KVyHjq<+9%k1mPN?5{wa2Tn4G?*Ng=8}E_0YK#Km?o5 zPctlXhK{SBHH{sAsSb{#6?kggk~cv!f1nLY0gRxOLdn?Ds@+l4K3{XJMeD|W@7hFK zRE|g%zZXYeldyo`CQ?0vmGY@`_Uc$9l|f_!neAiK46JpA9N8T>Phni&Mn&P}m>@p# z%1g9{Tq&rCel?VQPM|aIG&{rfoFm|atU8u3V_s8HTxxE$S)(~DyBiYaCn=~@P?gi4 z`2`sMI0rmXptErRBBpR~Zmef}R_(^%@dhC%dYhyj{C_6=pbq5$D7A)BnkvYGz!U0GFoB?>y z>y?pgpPOK}yj8h~*h^oIRxnR6V#2?~O@g~Z|EAMZ!0Rr(|9b3z!~=+?(+3p3|$I=!a!StOo zYzWp4=24WbSW2i75Axw?w^zzak5@*OlJ%E6h6!ILUCgL}PIBPU)l z{BfYlU;XCSwH zlIT)zexwX%an*7Ve|lNH9YvX%tt6yflA1tzzhA}^I2QCf|BNKZPYF(#t0MxX#?z<8 zE)*|Rh;&JX0^U+dalUw-`o*~6Q@~S6xhwM@Z(Y1?eCO6PG4_nWp))VVmE}HO`*@A& zW#b#Yw*jdaZpoca8s-fQe&1j1T>Z|9Y}f6omveD)Qr|;aI86#Rw;L^Ozp$8|S}~b) z&N3fZnovH)!uC$<6Oyfe{O~aDVbmA6PLq*#XmPrdnrUfpN0x+6Mz)l>$5w~vhGL`S zIR_?fFH6{dcSst~w<+ta7QT1TfYMV4Z67#r@8|jFyET&|iWDwy z++JUf!cID7$R~54SPaLp0#@B$k|Ldiod{((4NM&qB`H&WWb=s&StFE5UF1}2kDAiO zRODl#G$7Ao8FiHzB7#_#Mmh#9;l7n{?c!QQ&3PM_b`0-Mze#S#C6;L?7AZcp<-Uu` zVp5Sg?k*t(;X|p5X^IlcGV0Vi`V%V&uJJjagw}(pyuEIUpV_0)+*0c5a&R}8b3s@Y zEE?@;p z9_M*yiw%)KUeXIBZ{Cr+fcu4BHQ)rXFkRkqG+~W2g>un`IOZj8{RqIk3Zh+>!MAm zlVu;JwOC!XY1S^@8`_hf*|3=GEF^uj)fKJ55+~7fz+FgdmH#pzh8I)1#f^@3vnfvF zhLPtffAzIBu*{yTaPTf-!dwqPS#`#jSgkZ96x5sy!caHN3LLkT2qR4y4TE`+1Ym|9%2pAK@`@WZrEa10}Iyj z5R-w}PMSRDyK^$eUCt=$^;BOd`Z$E!txZy)GJrq$PMuo@9t%p`ni!_o+Xe($9>u== z1ih{A&1fa2JR9Mw3(Lh?OolaxLKI18)JdY81`YZwCGF=(3>6#(J`fQM7*z^nwzxu2 zC7j|U2|^}O)sNlvn1yZn%OVrK>`8bCpi=B%X)BM6E3IDb1j+Z{?z}hO5MMBv&)t~W z*J)7~=od05?}K+9;`az5MlEkZ+B;BLZIMcuVHYZlI5lBsLh5uz>5{#SD4|EXkE@4dbKZERN)a<+;WXeD$34j$24; zr5x?PoZOwt6kld#LRt!0n^+Li_W%o5Np9eQJL}Tn4tnyG#Q%HpXhx_M*`0>^&zIW& zZRPrG)4Xxjs_|SR|0U%2`MF5gn^QVv^G-$a-Z34kJFsRs3%!e)b&feBa)xi;%)&sa zlbQ925jA?8xCJVGgJw?uE^KQr^_{J%PJ?Kv$3f36hUxgpA#Yjh?YD}Ru9@7Y(8a4B z=xPG!j`5_fxbl~yeZ9tdcET6KTTeqXN3zX|3mNU6>PpM-%YF;xoqu#h<9t^=$#r$A z%#He$FAOZawTOKu5u$1ieE~ddw|&e@E~svACG|I-cN;;l^j+>sR_eDkJaZ-p1|kCW zt>N%4{(J1u+SmG_vz;GPPxBD#I(AOlXeN1q{xdSCIXm;JpK}yc!l+W#s+&7mVVNY5 zYb+F&x$IP_gW&-UlN1XHD$MptR8$7zF0aWRa#|R|?7UviGTEqVH`HrNgan}pu$1;Q zkyF`%$E&jY%Q2}D?F^)EBlT36vE#q&+H%HCbbWKOg46SY<<%;W)(&T`$fSe*M&VI8e zAoa^YjwVllb7_*(a7}gKMDzr$g?{f_QyNP0Hbm%W8f{3jpi5b$)5^i}0Y4EsOhp>w z`}NT?>AInUP~N$~v{L9JWphL@su@tSA*na^dC^3Z4bT-m#^d}{P1uHa_gRnOOL=j+ z$@Jj%99Djal^;b3LU&LyrVJfG&jp#0xG@9qn(FJS`J_S?67+Q}OGtN%J)#6YVh$8v zLJRlcw>j!FBkrpzpAwPV^wCq9y7zbqdh9t31h_hFZ%M*Si0!HXu2=gJnw9S$KqBg3jcN z0Cv2u+d+@h;#1fJj8x*L*PY{w%9GMo8Vk5enVr4l|buryUmn$G_ zu<+S2z1F0?P4TP}r9TG|f%*3Y$nm9#rO`B5;Tl7z@ZtBs{ZUfeifq}hB|}T_{3b7& zfc~skiBo&IzShL=mlhe8_Q#F}~>aSP-&sCDG( zi_78*g3+l9^W_NIkr*Dj7?oIT7%N4#&{B;?b+8HIm9;qEuAX|beCvKvW&UZN^60`- z1xC{00+*uvooY%V|GlHY{2=VWUH6x;==OYySGC{cH?rB*?JD!C2jiCH;W}LlPczOs z>I-achBs18EZ<|z((Jk4S0FB21c%?Z$95l7+?!ykncU=0KKyV@&62Z`k;*ws>2>7R z_A;?xzGJYIRgzp!uBL0>Yo9zSGIU?DQV|Y4wK(0VNuEiol@1pUNM4if`U0t`ZTBHO;F zn&gf3n_BHAhePyS85cM>BEDs+<$PeqBRN^V5L@Y_StN0Tbe5T>!?3U$7Ctye)X1Tk zm6c|4c#IZaMGK!40%;Rg83fWETx>LvZl&5A-^HjR~{vbkKBP-FRc3C8p7&=*M zIp7F4>xg5TA4kkHpPdJaN{{_N3F%vvkz0BDTNCOu-nmw0kiz$@xYDfc6&U5e%BjpU-4=&!>=goKtIjE8ZL--fh2CR zx34Bq4!pB~GuYj?>-dl)I?kZ0U;XP!VK)t>#9_@TXW6>PxP!Z)sr%{N4uz&8P$9#N zaD3mxFmPI7{#|tW+x4x_Ill#@m3%Jj;<=qF!j+w5OZ9x{?_E1L;QJ=&B8h=JG$DU? zb|ysb6Z5@vf{BWHZXm&lRU^GbcICo@f5@u;=RcK7uRNg8$lGbOeu(?Qmw?-wy(u-f z2yzZuO))p=ANVM<)!ICgB!<1$Kmgxp#uCpHl*+~pPxekSpP5XWRY7AOhWAQfA)deO z+`oU4-uB!_zd8Aslb>HZbM7pFcxNsJ0@+qM5r(9VlP-3w=Q59-e(&=j`aLIvYUSvq zym&fD`XA}Ei+s2#B9MFY`}K3b^j+zx-nh0zf^J2K{aACEL_|x5lu~*pSb2*x#6T^y zYLoIN9m!GNljGKKbS=>}}$+pFMb?4SaohZjxIt>A8yAK$*wq zxXjfb+)nw;vOhD_;zPtW}Ow*H?ceS55UX6toq?S(VH-bXBbW~-3O;>n#qZo%9$ z@Pt5SFWs*v9-Id)xc(y3_qTTUzsaEgY{i#0+}u6R2=M=@o-X3_0AMKcPO9c#4f^j> zqg8hG0R<~+A^EEx?wdZ>Xu%8q`gZS+R?g2S-rg1wVCGffd;hD=rr-rJu{U)8XOR9| zS2FJdkDt@zW*qgiwMyW2Y6^|;+pR_-|F!qOeh_5@Hb?tr>q7Uhy*Leeq#@uS@w-9) z{WV_-K@0HO!zX^XnT8Pb=oSI#@6Gn#2Ql*;t_$C!jRSsl0gCHFvO{a=fB*LHE~w+W zupGNk{%d<=fmzjK9KJ{NZ&2xuMnEf1f$sA8KY1EFqD2daJw0*%>TTNLGL%icMmyuLHT{JhH@fwq27kOF zwA{fH=l9=Ty7BmUWuh91C9yWX^=l-QZi0cj_?Hyjf1i{$zea*t{9OAd*Gws2#uMFk z!t2nj-V{ShAy3{=0>SGwzZT33TmyZ>g8#gMG8eL|UFmyp0(@;BhuZxJ37`+B!JYIx zKf6p62h2)}e=p^)0r)k=|N3%b`7b(weuVh-SNul4iSvE;C4~I^{g+(Ow04=`<9~hn zpJM@TxX1=U8Y{UCa;=OZE0TuVR~g^w`Dc8lb~Ei5H)eyXVGTVy@f_u^5=MM!BsfEN z5oa^be02OHn~UqrHx(Ksmd1J|zTLW%nsAxnvd16&0`IWEg-;IZuQ~v&D1|utBEGdp ztqN}w#gK)W`5JjTM(We>rhef_>*hUji&dc5h$^^)#c9|=D(0e?Gz=+-4L!F$+_?9+ zfmR{m6%hM$7X3u_w3mDI)z|I2!9uu+nw2}V#cpo8`po3M!fw)ZeWg1^v^TvxUp+^o z42aK<0=;R7$7+$J@r7@Jtd%VkZnL)#T?bn;ki62t05luK2#jJ5k-=z+_K$fz? zYV-sujvEr!&%9BYrJ6DN*JVoU+7pbGjNv1RPlY&*YgjNbZscVH&rDDCQgxO8a|VB} z+y87jhyp}P2?-n`@dX=R3;PGerar>#&+S2hK=Kx~76sb2d9{vS7ZRuoKHDv5-kp3YJfP3mgZ zPG@?iUk$y?)OiAdADXvo`x@(W3TpUlGIpC~cm#mNq01+)ckipbjxn$nzYjMFXo$0u z3y*+4+&&PQ9DULy5Kid73AEhc9Xyi))^X@3ckM z=#cr!kC2=JH;{~vfY)zx)rh(M#|ER~W~TFW3cir$;p^@%&(ggaWn~3c$B_s@pkZl) zFY0@}2uLEMSkTJ@?Fxc>YKVm0P!O*}{ce!HjMlUFUybvLzZuglCY2MM{LUI|9In}J)Y9dA2 z2H6eiyHuF%6-a%OHUs*mHlGf67EqQsc`t!>YH66tV>X?V79w%`55yXUk$~uP0)-L> zQ-1kgD|rZKR9zAE-43Ag_p&o#X`b<^YICYkSioqGB5}|Ziot#sC?(Dg#&cP{+*=t^ z9Ie($JOC22_2M;Z-lW!rJ_A76SPPjJptq3Jf7uCmEj!>H8e^6I)MvdB8K44|Of>PW z-fX>+0GW_yIfII^_#J7pH59_7F188RPzX@rehrVIE*>)QV3~2WzePZE!f^kKjC(Ed zLki2WnGoTLrcd|2io58=NosL6$JI5Yv&WXnT# zcRRmIhLn-ol>a4!T`evTxAW--bJ+2IA`5F@Jgj08eFZ=lQw=Z1_nI2?cx zUM-&qE(W5CfE~vR!;h30krc+s-Roal*ma)5cx+Ug-yr37R0nRO>=->+8}o^zEcyri zemh&OrxwIOAc8u(0*GqUn0e4s)Ev&oE3C^}d@i%!8_*;PKc!|^2L?MI)*!|qLvp#^ zX2J^#(KQL;s$)cu83;FWpQxtvPe3ud{$F`8&Sr_o$z)p)@R@>@MzdqY^v63kGFc>& zh@g+AUWr{!F_O$iHKJTeu77EZDk-WDt*$Q~0VLdeh>R2(B^U56mV_(twXz~t;SE_} zfEY_R@90`jVU+uk?9+zgAN|7i9Pz89GKdb9|1+# zL~Hto3gQewkx`W|JK|WOJBUfIm1P2fO%ZfnX7G@nLy+#EA0|w!{Pomx{?)?z=_~JL zc&fXEu;oPU;dF{+z=wPTBSnfZMA(dvc}^>&USy-d@Nq;mWS%%#1BVx%S3Vt(@6AS# zo!4pWhfkjHBjbv{%Oun#K|x#jD)B&f^kx;7PuzcXxaezM#eCfUQbzJ<>5u{G6QW10 z*+y=QDSmnpVgu6b;QVVb%FrU3SWp$7uDF0($*89b3AZ+qF-b@%@WG(?CWD9tt0JBBKKqLYjHp+x8ZVf1rNNHjq`21Y}EvRO}{kk%)F9yTGM zgIQ>cuK?k1r|p>cV$zT$8j`KePX3J&Ajn?HivQbUkLkMscm}z2{q76IgnJID>h_oD z>*`zms){3EdoGkoFM0qiY!e3M$gp_@-l+>a+eRuSB5a{Dy|OX`WE5X7h{1FXY%1o) zVlW3l7FMnYzxwWB9Uhw&sthu-mf}jUt<)Tr6m|%-PvQE`BaP{b$?N-l99Fr7pUC+K zE1lPtv#Bq6ZT@vxLkB!n%van#tw~8bL@#Sad?<*m-uFiFS{bUdpwd>n zvfnNnr~W!FTv@iAh+O$h0M@J;ShFyy)U$uSW)nmr2?<1%*%Pg3m%0&nXm#Dl-uL3Q zwr*aspOHX1e*7lkNY%~s0F-U*IA(8Up==zOtTOC65;?c|h;(Zc$WS}qI$u4UaZF5X z3+(7ennQZn=mmn1A)gVETqw^?|9*kmn;XX15y z^QU{j;rDJlv7Hc5gZ!-4)qEQ1QC1l@wR0+ zyUl`L9qH@jTgiP<;7vkou?34ZuqO`V)kWAq4m*!0C$vFyC4&o$2+7NShDrZea{tdi zm58sX-Py5y?VXY2o~?W1L!Xj>To}{wN!$=Hi7OhSc3X>IL&|{RMPfj}&E*Pjx zS_2O51duofYOjvpKzoS(RJ~oUrXjTLF9=m@KQX|jyU%z9Vg2O5HZ(axS~*OZ?(!r^ip5*K&eGv zlSD9?1(0)=ve*Gi<|82Vi&Ba1Xk#jX_B9rEb%y*VIB?S7paGKA}SQy&@hlY*?jf>#nn!$2A_q0(6 zg#JrZXfHbGy$AoiwFQi=kI3! zIT7^u0%NHwuTkBFot~>tr2Uc{>F;CspdPn4a&xY?1M6N%?lNY#rM3?6jO$bA!-!b} z=$^V&PpbG>8a&W1E|cnZlIM1-O=my@8W<%VoK-OSoG=VGYj?$h$YUB(!5l$N0iYbx z89-CyIzIm@d-$1Ht5yktDiEFId7qx-uK-!|9uTrb^syfX_%%~_3b0KL@g!BEk#|nVFyjOdM*YgkQP7$sLN?9Ob+F@@oozf{@>8Yg+6Yb!Vv%&%^ zfeVxKmK#!c8yAwjYf$OOz=>9s>#KtZZbS+b&uf<&j|iSiaOm_8d4?zRP!LGEYoY;C z(aq7wQz^qnQhFctL@{em_i{0*ywH*%B=E+r@mQhC@~rY(J^}2j;2(8&|B2Ngb6*0D zBsVZ26A?kK2jC;+5rd;kZ_eWvJ{0wB!200@IA=iAY8P)_WfT*-iJ}-OWQ}k zdOre1X^(h+2tB2S#@6eTqeDAtKJhaVo9Y0>%K4enlonhA!J3@%_4-9`AOv5QSJZTW ziv!RlGlRwEiinyC_mx=F_NE}xW>o1-88={_e+C<79@5h(_Zgv^02)s1E6Ysd+^mL{ z(T4~j3XfF|}xqT;q{jPoPK=E!4r^g6ku$1b__K60}TPrfRUhIl6&BW-vw6ue>7IE*ZM-KUDhQ zteP^VI<*nwIT-IOzst}=N)Tmb0Tw`3TqVz83DFxaelnQ!5okl1pugukzMsRXbSht{OA*K z;c&>%J6458Hg(7B$2T8m03dLPy8nf@$QeIQPbLM3^uFHv{nWZv=Es$KwK zYdvO8znk?Kgeq%7p#Ftu#1@2ME|0&=iX;}Co}g>F0rkMeMV`^LbTyxPaJlxuK1H&PB+~?1V^wj&S zw-dzZeJjM+a#yEQQacVy>cg(mltgM!uS$=p_MDu*bp3U^y0ice%0tlOE-pKR&6&zy zb3tIWg#kOoNQU63iPW~iNgB^Q!Ol1EZcI%cC+HcmzY^6CMd9O!8jm&%aN$+}sq4z< zmrbWQ-{*JEby^$cGCSQR7DuXGkPx-DN=ZHX9gNDebn zUv9KB=HyQIvVpPQ8vOF?-RtncrcBOmMnIlOGsmZM250~@AEhNk{^X@x8+01Qs9%~Y zhPe__;{}K_CzV;y=k=TbXtddSBVWq7b2p`^L007B2bn+KGTAqMWY{S1?{l{7D#Fq- z{lbv_ow5crrFqX6%wrRmlf6$Y9Ol1sz(js>sB5J|Wjf#{kBH{!#=te?MvcQ;lVi*t zq=Re7ap@x-pH%-6{VMn0cLBtz2*`equv{5_WC(tX34Zs zrDG<&A7gfxnlAxm65&-2RsQAQ9{&G}kcANufFSdQB)OBC=ch3IYS+v*B_Xxrhu|N#Nrnao094Esf7^Z$;zxzd0e--hB3ZyT zyu+enDjUUI1jz23fJClzyg!WB=@UhQ?sMgWG=T=v8Iq%#5j>EqUA&u^{R$5xWZkD@ zxPLWR{#<*QEB(}FMzR+iFso`E;f=X}ip|_^X6hpH0Z7i&x%Tm+pPSy@)oZ_+*An>+ zPDRlf&(no7B6qt$;IMoWX9A1VfD>zIJjm{`Q|CY@g>hKflkM zO!PRbT+44eTxj&LGM@+vJ`&LPjr!LH(SE2j4)9v<6fp2MfI&6XP+)1k`lpj3@gv&M ztBBI;;I9GAj21t@tSWF3{~8IO?MF(9jrBkSU_4zue*VWp@~BBJvELP^|Ly&tcH;f^ z6mX`tTvmg*I+s7Q>o(M1pjZ1HQMUz(INc#I?@EH;-C<^jX&N|maJAz-JpR4>|7)peoJCnzq6qck9?LHDSUhI<9Tdtm~soBKUGPy`olc{ z7~@R4l6poj=ws-gy_sJ4oY1ln za6frQ^}cgFN*8xOxoVyLd=EGe+~WIjRZVm2HNa_>eT~T>)j=j?Vn#z8n^;Ju?YwjIM~1KQpI`$`BL+LxP^(u zzh&s=gUaC2S3RkzzAVvpAa8k*De?EDh2dJi31Hpp%VVH4Z}xn~oj=@DXU^uZ)*4C* z%o_jhsoDcz{;s|6Q2MhydB#TumkJL{yqW$xE0B2&z}K8QZR6lSeZ%%cK=}yiE&Zwz zd7zYsD==8;Yyay{IUpI}{k5nlxc^?lpTz*E^1lW$7XK@t_|IF%$Lt-*6T{%HfUiNK&SI#tFn|MD4M>~UoyWD7ppe~Rm(E`c||o+WbpwzujDfRZH^ z_K~Cf!-@QS8N5K?N6~M_{GSy-e>My+d|g}A|Mu}BonR6jB$|FFB0-V+u2AArhxEMS zPQJ!6<^Pt-W_$t~)8^?ML;8C>!a(`N_l*XSQ=kONG?2pXEO@ftDfJ`KWugcdEUiJY z`=x^Du_q>|-5Y>>EW<^Qz?T?-GCP^cg!1*S75jD;bHKRR8^TIHL>_Iw@ewP|bK*x5)hn=3g%a;0?v)dN>!2 zvjbqWr+(tkE$Njh1EGNVn8D(WsiP$C6E|Ff;+mk?hkX~o9-?Mj!^ih9-J%4IT^oAk zfI&~*$8OXj-G*|t`#`*SQFR=bg04&+McCSg2w`4*NXpQAxa^j_undw(CLpf`$w&54 z{Od&eSmL%(T%r>Gxn=c{LrILXMP5P@mFd%|8-AS14G=+rXdf58Bxp0t9I zfY@36EQ&8}9jylNvhFB|O-%m|Z?mL}D*F`pI}ALx#5LJMGl4;C998qXb~P49cF8C3 z_5c<*MC*;LFn1}AUSGq}@*tm{ZtJ`P87(OSDdLgzc$>KL#5U7&0DVQs$FTo(pUcuT zoK_xw@5xIokd_D|Jyk`eN#Ax61XT1%83;bKtKIixtdqN%aJe+VlyMI=g8XfcBWLaJ z$YdoL2GRj#%h@@j-X}Yh2qD+a7yN)IEPn3vJI$_#0*R$D1%WLw7knpHsN4RCc^-~b zD(!`?#O>@rm$NdgcRF|q)ExAxT>YhwKqbLTSR6^X&zTF4Zy(G>A8OQ|WXF;gUOeYU z_~U;2?H48d8$(C;de8q_jQdBj!Vq&lPp1m+@C<$4y>gpM{va{!lJ+HkVlr>Kiw zA0ICYy7#1M(9rwXxH+rErm~ZU&PXD zUk704p{`l`p71I3d%EXA7G&H@l^@gc4nDfp=|NehD2(kb8*z77@jN)Iy{4-2l?i+O z@l`oLvXbbvF{AjfIE@j=?Mdu63bOr@yb=`_P+oS$S!T$d zvVf7GkXg@r&dw`)hHJmQ>d<+v^c`6~UY9U9)1*?P49ls*mI~yPW4 zZ~XGY0#q&P>CE0E`Ms|`0NXzAvJGCO>&F6Bu88h5kFVLpuy)7@ z92UP1swr$`1oe}|Rkm<}s;^Q>3)sSs#RbN|6t8`GcS7vIS&IXHHJD{455StMq|@3d z_nN2lu}5dP-VJyo=&@e{EG^Sq%r$V+Y#xGdO6fS5LU7c-3?viZbtDO*ZtP8XY*eTX z(FEnJ=quBz_ZHj|*HG_o%R@}?1z^-`(`*NZs$8NhoANUG8MC@T__ zM^_@##e&y_wx6JYyHoTF+dT zDy6#bFArUCEUm-xIvW|JXi37ku1LJ=d#>~M?!`J;?5M4>TF3eQ@s9m57M>pdtoDE( zQ9?ErCc(+K$Zc{M`_4yCiA07kW_>z>a2@i*?9NO+S*q z7TKa#0R%``qWf}|ojItEgTEsX;x$0yVH%eKt$a&XKfB=5lJ2qR6R2j1YbH?>Ay(~g zdO5&#_!pgKJMBo*zT|nJwqcpp;@3>>qGybSYiQ7IZN``c7lA$42P@TZw}Wk0gFLzX z5=uQEY*Vd<_6FIvi-4$E=U#~07gSA_%`q6l0{(tx)&wTy4VGWjpqffk;?9hoY8rW~ zZANl`<9*J|Xn6JG+*e+d&~5S3!1ev!9NW?2u38-%_$Yyc7u+hJa$3Qt0I#z}$A-D& zjPk3koT>^M{T*14b|@&HL66~mg{&U9K!y?#2tk)F!+ANr`DGQ&#g&4}*9>dC+0$Iy z$KJ)cr(cj`DK!2ch*>B!KA^2EhR&jxd~v&t_=%MSFuDKSa7qcA!<|$jf-MV%bi}KVijLP{%p%asx2#tlIDfK-Ut`A?Wwg*?_0W3lEHl zavOIVlK*6!`O1-x2kf>g>CeiskIiJr7(|byPxSgKv+ zTC|exyf(_J6Ngc{-?P-0fu!_0Cir$pric+J&0l;GFovVxbXErQSWF`(YTyBW(;1Yz zwb*rjz(Vd>1K{4uH=WQ~)Vtgn`=oh!AZMXd6)c8c0zm`C>4Gg{9|(v%(-&Q7)+k+e zyXruGnj}L}gL3Hzblev2>t7(hZ06i6O$T!chkF5nXc(93TLxuIY{;EX{+Tti#M7|~ z2XZ>{8BoJB-#e3EwcTb{OT)5w*HL(pjLT+h*dJOs(Hqzx4HFzhTwspG(XF6lZXBL^ zW%)#kk?(S)CTFn9%5u#hG+JKS-Bg^F$OA?`C`g{J!zwMXdn|iU1suz9c4XAH;Lzbb z6~#-B{9V2Ny)PgA=#pGhjJ5g(fn(a(#!p_;Ug-#3pL!o z&tKXH6KTIXo7z3C>E<9yr9T=2RvT?cXr<}74>c!Yk||}6Z)RFg8=1YRBg?+z^Sst2 zr%CyV?Ei}V=43@`1G|NZrQcP&l)r`^+JGEy*y#IRJo>*%cbS=Rz>2>Qq;6$Mvoq}( zfqO0u%!c*n8R%?1GKB68;EH~<7;#hs1i%b*{O#IgFN_8Hokh8FmMG0tD8M5|rQu&V zNrFNRDBKqxB6oXb_4jZ|gx>cucXk{ErrzIP1qVJ}quSjCreea9)@!gfNC3~|w&k_r zK(SRug1wA!Ls1(o1>g%Bx5_n5ebunL zeX=cv!Uv#)vvGemT(PNx`pX(vR$K1UczgtetB&}+eT|r7p@SdiaY$-Bd;aT3PwCzy z+ky=M%O=E?cASjdH}w_@OjajrYpVg&twA1O!Hdc$1l>&|kh>&?IFOnumOe9hI0At7 z%n7G&esx&DDZ%qeiO0hLqAa9N9%379`|k1yqae}RQemD$+3HM)cA#~+v3@mg797sM zmrw5}w6{$Yt!JE(=p2_UbEH3b_!1m}bkBFRc?{bhd{1*OeUj3w+E(CAYd9V1p&!|_ zM&BdS<)pp0F4EI4WA5u<=>_ey9BcNhyAKruD72zXHlfRh2cVeYLwyA}CF;o`Gzs#{ z`O@?XY?Ye3o|>WGSbIiD1naAgvalT)C;KR-9Yp@|MLh4)NXvl|Fw`2uYTic{`T9=d zFL)+s1d$^;@?mE39eGXLVNu1mVaI2gwF{V{8SRMHqQUR}$%Va%df=PASm z^^Od$>REJ{t!~`+dDNk;pyqss;R|r~CO*>9yQ_POd#=9A`kh9{T5ey+-gufPoA$N` z^;@>!{JzR9N-a|+k)snVC9M#Q+`MdBvnzb~P3EYL%s1b2lgZf@6%R57`j3RZ6 z66_XBmegyt_oambpzd-I>0+x%tEXSsSTG2<=xPos(>9)T^47DK z|9Bf=Xs@T1_-S;h-m^~VWT#(l2pzbOa@h`{BvDyad?V(agPLP%)*xFf^R@bHHhP*Y@ z^5S`_oOOj#RgtE;y)~BJAeA+OON%+P1iJFR{vkptP%b5Ot(hR&iGn7DhWPk$x}q-2 ztpZTVny;M?GDdNn7GX}y{jF=0>GGtcT$T~K_`+>`lf4b~@Pr)pHUnPC+5}dLd56gZ zA*UJ|vh0r`yoafd11E<}DZJtDvon)Hx!D_(d~X@mTi-_6x6;!_+99~y4y}>?9Kiif z%EI*=T!tOu;^02hRf@7u(;VzW3uJ03u5vy95M(%~8a7`~dPdd8?hBLJd-U+neV2M{ z)stJUl-U0goaxs(jSo;!H2}8&7!!_k)qXF|NOJ3;_1=^gs4gASsUL-u`>d6<<15cL z>)0JW0ohQo5b`ZbZYXa(3HKG9;?*wmKz`8ippM!ROsYER}981lS$(d`|#XVYBx>hyAUDmW5q_2OF0+k4M z@0f@^@S?tar}Y!zLr|H=g>os-w+;_Ft-d@#hR%;iZ0H`lYNvtg5LWwd^ZV)ZvnmQb zX{!n9{g|CO8O0Jen!d(eLhdrm2!oVQf5>^aKUwb_(y6XRTZ8t&9Sml0fFQOm4dTu( zF1`yvX&NdbSh&Yq6h3OfqOWeqIX7cK++q_RgBbq;<9CVkcHi3JeE|-4b&ad^om;5m z)3mARd;*=&>2m(Q$yW_-j@a+sG+&)j%oq*xPEB4;8eyx%AH6vAj5jI&Sg&&nTq|r$ z>HT=1%(6DiN$BWJc@Apb{aek^vhGUZvBsc4B|#E&N?o-L5-H0j&^M@OQd$m4znB=V zX-G=haf*lKu2giiT_Rgag48zB_Bai3Pwe4BK8TCp;$T6|ssNofCJ1AjBwIjsQygPp zj1&u%aXP8r?q#wa&5Slg_}*C2-3aWokFPtlt&~PBj_hnW6cwV5o+-U}{BH|^9q$0HWjZ&-%S=P$>OJKgnMtmwmLlak{J@}N;3 z(XK0t95ZV{b{oTr4uQSAV8zjg7&|1K^}yU}=jDpTxotcDao2UDc)6h% zzLvQfmR+te$1^8_w4EpV4}vkVr7t^(*DzK`-aE&}n!5}bZQZOG;iChGK8HHt_T7Xb z{#P4Mp&fhm=T7Xs;eSj8B3W9m2!tj(5x~q)t>JsV6 z?U$%cQyEn!zG@`&HpNsFhEh{b<4kT-Mb%5W1Q-mYh+d9%R=rh8WYit_BA~l$B_CNS zgsUH{QF$Jx63m#FcOp%pdbN=w&)h@6GAFf&MmSq4Km0rGEeQs7Tv=%<>d;MQcy}fn zYDP#J^^GtC&&I!wF>tJDD_vER_o{UH zZ^69`vrt6&DBLxsi(_$=7u08r-(0dU!VDDiMOgREHGra-LFb7IDXm42QeHB2-!e`e zriVJF1WcG=XsS%h))3>5#U-{)1b*L7qhL?kjfm!FGkTwy!@9Ok{b16duDkTux8eD_ z0`#Q(kbZlo@WSlDkxWVDOcE7G@x}m2y4Y3Etw^4PgfCEj>!FEY0c-EcAdfqawVU@5 z6LT%^tWkNVLC-xWk3;yDik#Z_*1)|f%~<-;ekY!>I6Ip#g-UT_5qjRF@fjIJ?fe>z zka}96pUbIvIdoImlG6lXva8JGeuAz!$R&EFsthSubCG4nKP;O;0y6qffwQfI|09>jg+p+36^h; zQPc3JlE}X=J{EU8o*=fRM3pofEI0REHKfS#kUjhWCS-4vh=+iGf3g$MuEs+WsKtHko%Bq$V_Q!mkel z_dzTqtWPNlVIPlinQ0q$aO*y{NGcC550`50e!_0yB})j{B9T(vt8VKIgO1gu&x~+eZqPR+|48}p*sa7I%n>DyWI#Nlc(=jMZpA`*BDYzAsY~a|j zGTN%Qaq@)mSG$%Q#Yf#M*b#JIdvSRk;Zd}1|I}tJVd}V%qw!NKIh##|Y5P4*?&OelFTcYYZLFCU7K~~?{#lIp(C+q8USmjdhrS-pafIeea z7tvB-1nO{qgS#?*BPCr>i7a3{)3;yT_)YTrFke|DaX(3>_IWByeB8BHI%u8HI1!1E z7C(Lwkq3@8u7gZS2$gSc(z!g4inZe#-rY^Mq%Zm|*^JjWh*6*>TLT4k+)#|8Caga> ztgP;_^Xf2foDRKimOQv=<)fd0%2jYf3Vm?ooGZ1Y3~hMHBYzd>dm6cWaTJL~@Q;20 z>$DY8Gz@&hsp5gTAPugNDH9#;_+98mc7rlZI$sw(spdl{PGr>E?zeQk_i$wl_T;)- zRLNL@p>Q;n7KGY_%XXqlYe%UtqL8kLBROpCsNO@yK?yU&-k6-mCC=%Xs5E&-WNzh-M7&S+PjPjbke~cS<(w|Vp-q^mju;&c1F(MNoO4_R$40WlLbZ& zgV$x1zGDZ%Zxk@eE54c+}c?gr`Z?(WWa_Wi_pf9E;p-2aFuti9H(nQN}O;`1G!2*`4;Yh?5D zxhDMnK=tD>Pt0#XXKc*LW$-#XQA1S$TQ-?gd)H+k!NYx+>FgXeEIUT0)qE3VWN9gt zGph!T<^z6)t={N5O7t}3C-XDzKpO6G|NQtJ6C)8gG)VmvVG#@2CF~8ye09M+vBd8$ zO}C8!cWE`26(YR69R5@3q}#`L0siE>SRveV9E64WYob#rmCVdn7EZkzD9acAD z7S)XYmCBsru5QOh_j{8fP24pDV!fm66M|t;#{Ca1=T(O~M2Sb`tw`(^JqXD>Eef`w zW52~!1r+n5vCG3rHTMZbh|DMKh%^~7@ySiI17BWCx>@jkfXyQ9D!|W>kML!`D=|sL zCij!XAi|N5T0bxOBBl_hW8GV~S6;A>?iVT9f49A<+o=FAT%%xtGcBPQ|3f-t2!q1igIw{29KIBx zS5oE>IUl(`8O9pq*`HF|IXAGvd)_7{wo=SA*uc!w*!Yo3eMsyRmMT9T`83gDMYv@R zfQQ8&O3~E{gzSF({Pxj!`2M7>u4vJ}&>TnPXspCYDXg%`C(X6(a{Su&spTzoPa=~M zHhEZCqbj}+NAFuRM$+kEQ(sblGdA7q zALQTGq;bLtRS+3A98DVvA`%=Xc3$DGYWQLo>}EDAJ*ifBS-^9#S%E(38~=I6XWBiTtEL9Wii)^=;(gxPgWE#`o3l3e;kq=3 zv$^vO`mV(7`yF_WMaM4cutHM5iK3=lg0hRA$Kc)BAB&g^Hy2I)4Yub=yk{v5mT8p* z3H6-U_aT;Jf`>T#SrnzaH?cSCoGkJ3LgOB@F2}kC7NhQLyEE5IPSu;bZv8sGsjqw# zEvbofe-GrP#_haH^Ub@wzf`y^^GTLZ2W`V?-?eQ51nm}9wBL)a)pA6*=c8|na3Qn zhQgXTDh1Rt$Jnm){u9}$+2MGXTN_d5p@XiR2S4Ed!^aKqbpMj(L3{J~h-4L}{529g z{HD92Fx9;&X}A8XrQmKI$vk5od+z3g?vDrFxyMoO_0&hNQ;!-4$$t`MVBo@@Z&mC( zZhN?p5mVasC=>W|f)WxbKMP!cm2FnvLpg;LRG#du=v0Yq3n?tLHtam0xYunbK@t8L z*WX8SJRdtdR`N|SmC|CaDz>;trV{s(=Tj|w?J7)&GA^jUr;dbG6FHd$S(}}xvTOOc zUCsq+OrFjUnBfnsGz~vOC$V$nwrwEKug$fBbSE&8ifW(jf_Bk-Iwl3v@2M#gzk0I_ z*&aIr@VaQMDL#U9Ql6}=IEm_AJsc&AY$#b7!*Abs##`@iGaw~JBF6aQwh=T<%3Ov^ zhHd4!@GC`%s#{Q`>lKoaUW=!LZ!p-z)j5)uN)vfvG>Oe09f@n(U_Ys7i}yyF^jpuv?cNSKQ`N~}myg1S zrn(2et*r7MNtB!w3i#*P(K=2lC5Yn7d=w`V?ub&|Yh%>35pwZ#f8_QeSsfQ%XLq`AT*G@pf4N#NH%3X&ZSHnS$HX)-*sc>{g z>+BF8E)3%?@d>`v(Wb*b^5eYxeD=wa>PY*fH$G?UBb_fg+U8TSvk*v%O(gN$JwDPF zR7Femx&*UH=;<7da7n->?65^Lvue*$8(q9oIO{3y(=8q&|j zmTs3*dgwWuKuGT_OOw_1Idl0`Tt5u2p!GUykqLj--`wge#xOZ1&5Rib#r+Kd?(=pY zU0R93%F+a^d(OlVu6RZf@7W7K#VgwLT7SISayMJMN1w0DA%gw(+h0IJj33q>Wh?KRGi(w@5x6DQEy~jK8 zYI9tXk#XL%t`5lDEvFlki^A+;R@fZG%)B;71hUCk_!}$L^UndK3&_qMx{eA7WLJ*IK!k7M0oeK~!`Ol%qHD4cf zg8%|=MKKV!%gp`?tyE;Fr1m!pV+{QK3&a2|(n-(L?259IG|mDVB&lc}>Vu*ehlhjw4G zhT`E=@UJB&$+FK0#v4hvViqW~if}2#>61v54S`#@_8~2plH8M`U4|&dF%ujVZO(yq z2uo<)N1nrv-`n4kwx7o>7&9H7x zEMmhq!94ZiFdwTP@Q%)R3(WN5I;8d6yQwu|Qz>cQ$C5^7L^JzGkxJ3f#`e&qbvRL%x5?KiI3e2SCT^jO>K)*-$=6KRpt0s z>ih(^yHLj5$S9iI_d?LkI0gO>LxwGwg=OmN3wZF;)YaH=`!rF`2Mss-7A5$#J-Mzj6P3#m2Eb z|A!GNRnhGxjL|(ufMkNgrq?9Ny-{M3A}HtLw^IyxAC3K&CNGg;Ct-zb;5SJijq=r3 zXCYcepYaKQRF9UYtj%?daAy&St!S}G#fAC{Hd-tT%-J4%zn zeMpG(zBJtHNE&jTzXZa?KX;E6X7z>zX#E$cO{WD{wTzw!Qi_>=#_5-%2z0>9RF{>D zOtcG%Ja1%JV^_qCI)dQ(8@ngV^X*|bnDdApCY+7%y9`JKqh(x_5<7AwgULlrnl(r< zTH7SY5t6!}=%jTl_-tfwaZ}qVh&Namb&d{q#b-`ntkE|$+FK!n#FaJdWmkiNWI%rQ z_pl$pyCEJs9TTHO8Ey9&^p|hFJVjX~>mr6^2k2~78QuJwHfz$kP32g^5qhVkaeR12 zuAp)2JxthEzHW4X-TAopyRl8MdZ7+*-p;($|d>>A^9m;%iz2Ls}--EVAMR0RD-KnGG? znDT1CT0;8D=!h98HJX<`Re9dg2GY8%m2+RERFgq??TZmVu?V|zdkr83Re!dQo4mU| zT`jM1pX;F|HglI8&9iIJ3*AeLn7mom#n@}b?lI#u86boLC04Xq6RFq{2geae+|d0f z^J?$kKP~2*AuFj_V-N(|{p^Y6TeU%7o%_Hz6F0?2F1|E<)=Q$HT1v9vIGT!L8JOUlXoC(lz5fL z0ZmvY)avZ&9f#>sQ{k?>Z0)YbEIoI7LDs&*y^ycYHmm1DG-v15-W$ti(rFL;l?DKt z*#l+Kj<*7!@Qr3L_vospb`PFLgb8Vs!S$Llg66F#B}=PVw<5uFVTtv&5JAUrguSx( z{hHfgD|H(9+d1nz&5O`JxAJ7+RBCHU?Huf89c;u7Z`%Pb0sq>H##vR8$Don$MuH3~ znGh?Et%+Mw8%vjx&+f;;uW;+r(K8)T;=OZ-rFb{a#J}BK%MQatI$U`?#v380Z7!x# ziF`aGRg zg$l~g<1&9lFh`ayF6yFT(zKloJj@_>_4!mZb%y`wciY$wA=|D?XBij3MngcWPMsQj zahhiPbz5*V{Wg~B!=#lGr?mQ@O&E42YQwLHB*t+Rl^!wEuIzb;-CG79(#SRP49?5R z>XC*8Jdt^2xKhA&G>jGtMWUcvaJtV34vG%4N7<=8>KOD0pq9CPu26e%w(_&%EZbsx zzt!I3{-?dpbKEb)Fpr}^ zlk3fhlvE=`U=g#J(f5abVw(I7F`h(BTiV<0+Gsl~vky5*5Q*B(lbSEc_CZ(I6cC@y z*KU+ImB7#u<4jc@k6bJ$)Slg^`qt7K@gG*B)_F&6O#z(TZyJ+@eWmED;6n zAlRZjC>(g2FOnH%sB4_SQ7O$e)%onf97|+MyJSkhJ@9N(d};{vS!-GzB#F$ZOeBA~ zbM8I6drns4@`r2oH1cc#B?NT*{I^g%(5;sjc%j7TGomLV$~&g;h8TBaZUp%sg*BgI zNmCxL_a3*S_tP~7_Rmb{h>bBjPH@mbVVV}z&vjPw3zl6{e*f8aUq}KxOwspNU&Cl?g0cE_4=rE87-XC+#qn^VFp?DM2D?kIz2%G% z1clxc3cn0ez|2r2qua?$RnOgutsRl1iw%j&y$ma4;m;c2&Z3^TbosDgeX!0zOiQ!_ z(7D#aNq8BWRtpyV$R4kfi2pE!zg%7qus(>58l|9Ox^a5`=h9xJ$krl*n&Ol~;jMrl zqyO1i)2lM=o=;80qIWxxahP~c550)Ew;wT2?tgA4u=O+KUxu|FYonDha4vGqtwl9# zsaXiW7oiTM_a}ekJ#g>Nh>`t_uj)+Pm`XlOhdu6g8`dZs`*p>YWa=J`{}tPXwD21i zrE<=oWwOSfE6coCSyNBjl4wnlXl8Fj6av-?Uy9yoCs6z%1F_mV$khn%ex zH5Ka&D;90p7X~!rPi)%Cj)e%yCR?dL7Hldp)1B8Rsq2OE-N{GzYj1Cl2CNzL=V515 zqIV!K>BU(vd1eZ>vFnVmM-4(Wv(3}VahGrN-ySoY*4KD*4~l$ z`{=>R2#P^&FD*gq<%NQspz!h@>mj_5%v)#Cd1sITgRV;kJq?S0qW%88I=%Q1e}w&xMmu+9jP#E} zWv5*EO)dYgYPW7b&uG;1Ag35Co=GRu03W^fHc(5W_L7_7{xdnZq^Jhyswn{Nq*k^f zpw7r9BVt5nO0iZy!#?T-SaSS$<3*qx+vaBay}ysnvymqz@vK~Pn_$1J(g=+SQzpL) zBoSQ5I6TJ~cjNs7shay5peYmLf-9PHwtrtGD5tS#4B+hGknIp(igD>ik^%7%okOWU#p34e#1?Z?bc>BC9eFzbv;T0KLq0>?m7dD@XR zP+hZM$RZMQ2e!t2z)Tr4rV9WJ0CeRuDW;)n)bD7|zetYf?bj~aE#^c}wnmEZC4gpg zn)ex!FD>PEuLn3mR_U;2WDd|2kZl&Xi01(=h&@5uWjlk?uQ+{WonNF(*?$kTlTCq+ z`vV7sx1+p=^pY}hV?G{MKQ>d)yHZL(;W?ixsOr{2vJ|;eUK0@!9CHKp)>fQE83rmE z#uC|}s6Lx_0i@cxMTFfzRd!hB-cGA>Z&Bk-ZpCK>7oL{DM5C!CGFX@ATf+md%4O0S8M><5FKxhzY#qy< z)DmnL*$MYNH;P!es-Z481)S<>^(>OjI&qAOdZBI3n^p7i)SN`y&gYG_V_%qP3^CDk zolFDyA6H&Z4!+8=li3?2Ih72p9<#W&*Ct?+GBw(-m?-X_v3!}~`i1b1LIs&bMbtTo zU9@?0fKzrd2E@!jgm=#7wm^$yo5WpUS9Ex+ev9gzJgg4&OH;x7J!jd$JS{u~v0CM}WC z4k1RP=4lb@=c&q@VSd<_GOUxG!{>ajT^fI2px+B+^e+a;gYCv~M$bH2MP-!+RxiX> z&aX&meBD;IyeT;uFT9P~>S^IF&b^!FnHZ88L6q)Be@J@X;66w>O^cCuEGw>=)dipC zE^HdjG3}+5ugm+_KI|aR4@%={PYmuyF?!~*ZsYfEHZqK{D~{NBAC{4qFb6utlxst% z{Cxh}*?(f9ofBS~Mo75?>w2v2Lvvp=Gz0d4Z{*(dT&(6YpH#;R8knz?qB^Asqqw1g z%{;Id!Be5N{!`u<5$&{fo6Nn-dwUh0bMa?WY5uCwy^VvRK=a7z;_wV|F~@!L^ryC4 zS;QeIT`vX32$Lj@BkFuJ9;7NjQb-B)$6tWKe|hdun?X(Ob-C!Vh<#rS8Yd2t4L>kQ zeaPSX=A<^<{tE4%wdW{^TOI82vXW+-iKV<2&NhSoAKq&~X;ZV_^+&3kv0s_c!qjcv*johqKhId2y} zo8fwSkm<2)bhb52d90X0zoHlOaCbhb3tA5XMwBu`!cDbF^WZpeL<*JQ>WZP|fi?3L z=BiZ9xyc|-z$YM30Fpf5_|~{7X$ye;5zP^Y5VB+0R)9I%zLwgm->Ts1T6$@XK zB=TB-_7~F=F^;pAuKAl30!AsnuW$9&=q^sSN^BxBow7c?qX~Wt{;>w|;Y5eK6hEP- z*5?v^!;Kj@8A=x?!5c-Zh*B{wJa|BP<4QSp*0Q072(tE0uZn{4HrrgUow4bAv;fYr z0^vw6C{NVmXWU-R6+V`y(ZI=&U2ms`KiE*9owJY%b5g^daIX&|Zw6lft=tWxsdNPs zurv2PF2UjH%;&0c)ma>|Js@gtSv7a9TQ!aRecSR}dZ_FTe`(r5l@w!B3%lUsUbw~5 zFIT0J8W#oA0?NGEsQ8L9pkc-?nKsiSD_A4dgAQH(5F-pU>qPiAtB7>FB+2meu)c zOqY-?<+HNrWO4ODzYDaqcpCeCx?x+%?G;YTNlHm!NCZi0`yqvtJE-g@$ats1&EQX8 zb1WE2AvMPm5TuilMIWGP6to-3LjsTy<%&! zt@z!%ySObeh{=vBvT|e+So+|$>f!K*0u;|HOk5UTWc=Gz_-9|C&^0=u65}nO>pKq^ z82kc>5AT#Q+|GoXbQD0i4@V@<=AYifxbHumhg-h_ap2G)J{Jjx;+Oz%Da;8SvlZJ} zD&yVvXDYn@F6oL2V7C02cbK)T1Y2V5aa#zK6oqksL_-Yi0n1cQr45@VH>1VW&io3X z4e_L&IX{Nm%O5l&8c!ald9kSTa_LZ#t#Ey%k+5NDN#DbTen#g>k;hGKaS+GG_7YVt zPfJ0h_!h|8vj+3Q04|mEJLweZC%R4{F$E24Sff&S5&2jJayUAhbL&Q>>A_R0dCsQX zLcPO^+ylGJ+hkroC*6C3OO&0}B)o}%UvGp7J;kp92rRa~o=+tWhIyoN<>nG!qzG%I;Mm6ztGD);o3DxJrdda(l$pZ4noZh7H4MeA#gN{oCbuMRH z7{j6ahMggen+dk49Vo?Q23TEURin4?uX|qBMAc;aL7U84Eb@`h{?wAJc7FOPul}aXh$yQbU~X#r0Y^=2#Oi5TsCPW#(`7|?w30yy1yGBZAy4d3U z37_v`J$+WH|Cq!s-dS0-OEAP_vd?qdv`*`;WIFumz>BLY7^P?4)2_N?VTco}n_Yo% zUh7tfcBz%wO_sE;I#aT}EN^x|K(;a=({Y`z)p%Hz8$gL197}f!UdP3A2r~M*$ogQR zMRsg=b&}Vx(emo2>>r4Wz5TZH{mJ$>pY5coNB3?@r|PL%Y}m{b9TKZ2lR$^(I?ME- z?OO%Y^rZlX8=A$!P0mv!8>;o2)%)ExHxD(V(O6A9{hAO8l(NNll`X;oWlNQkcYF0w z3dvMcmq`$l{;ESp{kiOS6Gk;hi*HV3O#~0gA8iqD;jj&fUTbLikKVhH?Pnkn8=ou~ z?cwKo(xxC~!~VZtI?`YmeeTdrlAJSdZ3rmtq*~fAakc7{;FX_z6vB~*@A(evHccUj zM4Ty*)`3DChO4|prRe6b6c-r5B>L6Xwtu0)b-r*oO^o0*reKUJ;equkncGoOdUG3S zw}@-`j!cyMtr*V$q%e!5lLa7zYi$l3Ep0@+4%HW*qqhL4==*AG$~%&Tv^^y`ej_M^ zRYe=d>G|BB>lcJv@~9$F?)U~Iu)-cGAHHFae*Q*~O5(0DMJW^aQjp(_bt!34rQUu( zD&f@=1_@Up+-ky=Pt+`?BjlrXj^zZu2sKOeMIwmPldKl%YY1hL_|lna+CaC3h$`Aq z_;D!DI9dYslQ(`)o)e5ZMq@bHD)(XiXQ~Q7{hY0NTHAV|dZe+Y?t6e)t-T_@jgS+^ z>-d22NlyphCwK8|ww>$jcQ=GMQLiRj0PCjjWW870`QZsw@UIb}(xo?#Fdg#>GpPbX zG|gEgvB8|UPU0l7eK_Yp5qVGRS}g?L#rW$Yb28}G`AW0kEX$}?>{*EE?SUqxmqY-2 z`=@b<71t@|5BC-17i*je96Gt_?)O2&9;DASMpHlzvoZ#TscW{})Bu%4V6X7pkVq#d z+DyFGAP2Aa6%FpoCujG~{%W%kL@A5FbIR|{sCo9O8%^t4oXq)Xh||jPvQRY+Isd6{ByD8> z1(7aSl^7wh1Q!3kmmY?Y?CYOuOK*bsulr6n(qxjW9ky>%FYvg!m$!xm30}WX;eVfk zOOg${R((IAvoYpV8nJ$V3elud?e> zpK`f6{I{`T2FAvN)H;OqSijJo_I`*b3N!JPk+p_shUfJaGIBP9_CwrLByQaLsOe4K z=cPn&Nl91t?>7rOS@gqX+O&Ez^)ASUugabfkC6PLKqs8!w@LmPFQF=%&P!ETdQU;~ z(V!-4s9ll3rb*~5L171mX#$y;V7kNUH{mGzCbpr5DA&Uf;TMT!6_aVZK@ z;PD`$gE1sI6I`+8988u=f^|?eco?4c+c>zZwsWN6izyqyB;tNM(nh#)E1b2(mpnS_ ziaP>w?W128Bix5-hm#**2<|(O7h2F{llK=;P6!|UAi;Q3yDs11n{}PGKdKT%zfa(V zh|f7zWXPkFF4P@*+UwtIr{6A}COn;fhGwdi;PPbO*&#viiSfpM{FjiJE)ynZ1XN z-wM=tYyg&k-BJKHu*Kr>Ft+Iuk+0|3@U;QC67}vq$x`vhJfy@V>aLd?eX&@Pm^_F! z=ZA}nc3VR&rYL;RhY+mAtQ*rKqLzrCMm>E`8iTAw`>NMt_AEZV5WX}#MgUU#L?;|v zdW*MzxKPM#B)aKrnf2o7G>eCjoSQ1jo&7(i{Gj_h&m6PvcJLS7*W^x?|@!x5$^6<#zzUL4x!7YNV^ zC1(If=qiAEQEP;Es5a*7Ghs{DWTq)bBtwjs`5(YB7a%eD$l^t!8pBCHxgHVID8Bhl zlzcd6X?%CFEslJB5pb9J<7YN>f3Q7VPUYE9`;P^=d7nW=EPBdlU zwUfB>Vhc;YfUJDmvqe2KwQL1aV4;I2%3}kqwgZ(q2`Z(>Olp_jKr(o`#{A%aQovqj z6EIy>{gJ+%Yktn8@}nkD@q+EP?>A$MJ@XoRdv^h*@$*~lO6 z=7$aPYqy;AG)Gr&@{C4d*qS~+k=Nhr_M*(PO6)E%RBaCpJ*l2S`P0N-ZkBIOKYtq~ zTWS;Z19f7SW~g>=MI+&Q=w(&xbElXA=Ps8fO4upGz2hkNo6X{{Fji>?b-fSAA1X+F zNRqgzU@;y~{H0`~d%vdjbhE`Ly5k$uC=)LIJ~R^-gz>#&d4igUnI8FUDDsyh&tdCkT2%dLXJB<5;#$JMX8ecKji=rMPTiiY&WECjzpVa8vk<`xkIhH#sFX{U{x63G zy9pKs<0NfKZ^s3X6D+W$>onxd&nP@K*G5J}=*ZOY0akutuxQ(Za))&Hw^Ge-z068c zh*w@b4_vKlyM`c4dOdl9Bgd1Iz1q_k%Z4I&3~P<#TPzZQtIz?{B~DWZc;DIgEhsQF zLNtP5@RxTyB@@F>eUT>1Kge1~5OG>1Nc9rs@q0W1n#pPkgO}#I8trOV3zn0@62B=~ z^$Q-wuL1xaXS;3k-N=YnP*9N7LvQJKGLrgEaYWPGaESYj^)#LqEI+HL1m6DlylPz} z^6kmf7GV#MdV58|a8W*;bT*xt00iQ%eDgJ_j5dH?DCU*Ew>w6IA0>6!s9tI)u_mCO zc*_%eG%Btn(5KFvp9r>Hqfvf@CX%Jki^E?54b@xV{^;HN3poJvn6n#|aSzQt=j2lz zH7rca?lHAky8H1|**^Z8<4(KYZ-%85_I@5J484J$&D_-&Pq?pOnrY5=@L|$z8Ghj5 z3Rv6BSK!L_1$kpZ5Nh13?xmD@Ni1iK=QD8Yj3HU=p9Gt20;1@v4y5W*QQ0lz2j`~B z@@%C~&=AwD&65u@E9}Jsank+4{%cmYA5Mg!D$)Z>r9GSx{-^A9D4Md(i=nR-GC9&3 zAD=fj9878(i3ZaA`2FQ@cJ!|NW?UX4TeN+!tZ-8B#94Hp zRZeiY!>UNVz@qx&?>8bvXx!J9L}i!DzD>L(^K45h(YdpNNj-#0hb2@=EXf*2Ff{=W)o}k|+r%oVZRTWNu!iII@uo9dUyOmC z&up&EN>``LVdJJyM6dqCD%CjmrE$H9hH{nz*~0nd?}p$_#w$)$3dH+N9xC@Hxj{{R z4!8R8eb|SSLxrX}#|eqZxA}9k0-lJ?w{)&ezXs;fB%UVrT;HCn>pm`smK|LiSvh{$ zHJn}0q0__I#ZR-Sy|m;g3@t9XxrO1;b+`Z6UK3>y!p}N@bA2&;*cXFfTx}1tJt}9u zHF2+-)+M;NG+2y1mXqX|e@T}U=v>q(IlUV~wQz&G>sHs9x!1X^nzY`W$1q^EkQ$mW2YxY8<-D#7}jX0$G^z@m}+>6KO$cfWgOwy~fA9GS-! zoTChaQY=F6^(=4G)rfX{HNnl3=8$+j>&CUj0TQgE!z{e$g16N$Qb+1bl)Ko3`BYs> z_io{z7w!i6vASM3oYFx``qmnDtI~G=-=obxzgw4j0*}@^>9#ZdZ(Bo=>M7(ykHaUe zeG*D0hA%|10yaDr6oQAVpP^`Ddvi5xD<9S_VFSPAy?Vk0cZKm{Zd)8-8pMR*5* zkS8*p=u}y0D`Rn$hPuZ_)NqwvFAJ;aS>70x*$4p45eEq5`ll;rLOjJ^(|h7;;Xh9p zbn|&nl21O)BI~schrhBV;y+p3{1ZJ9#{Sz~>fLECjA&@%E6&bO(06;`#*W@?IfDl>g&)>-GJ` z@R>kg;*4#QX(Ohs(bbcvvNe5U2=@Put4j}<7**0BGKd_LP{^1hsZ z`3J3nDa(B+9|9Vz;nZ0;x4k(Yx7%59?brsD1k4wZz7rI0q2zOrn*Agj&(S6Y!aw~Vi;z+Tq|3^ivr|$u4 zI;Fjd?^(pkCZJpten~))$U;uQ-R(_hp1;BjJ#BsybaT8xp+-U#_#FWae*|IG*AYOB zGhV2}%}N{1%27#a7=FqygoQy~}J%-jEm%ieCoa{9a+S zWF&1z9wv7u#Cok8L#fFf0!kxywjZ~`onhVm;0tV$m;1UaKD5`N!dOs@bI^=*JZE8D z!c>zms?R~C3a`=E;;XBEgrPBbhnh3T2^d*6woiwUx70OABWe>?^yv zd*NX9)4AerIeKhFdFjn4nU;g)+66^O5hC!d&26Pl#5~6Tb?A}*SJ*|_%fCR#`Pv;a z*w}iww=>TF2ZGk;D0kBK;_>^v;*JO1h4Sun-oIiw(@LI`xp&k~G5p#U6dzN{>8$Ur zY@&@{eP)cAsVxs_$PX?m|7LCUanNaXp~5`+Pj9cSi1;HvctuVfbZabx^seVS>jMqs zBlOW9L%kk+0uxreJ+frRU4mt%b3+qgnd;ASW$LaA-!!as|8}HMm5|DT%@tC?eryQ*8Pxq6({PE`Ee$s+|Ba#|{C_wHfERlm|gkA+ZvCPZ}%|aa5Q3xUJ&9pYI>h zC2-P9S)oZ;((8z~tLYW6f&C|2=Phd&Nu1>1Lb0PfJfSzxt? zHTqm!{b6HcqZVUxbCbaRt-st8MWUyKnCa37V7eXKtB7h+YI6@{LBlInK7V-pqJ~Fh zT&FZE-OY^o&lB<6U*=F(1DW{GdPE^ zjLWF?na5#It&d-2Zv(1Ah0CO~_W{`cfE=9$mkwNV>x4BH-p;OCh-x>y^mBl8HspDJSvndU9w0g&{BcsA& z0f$h%_>&jG004Yo|DfCO+nz4Vnr?*DabM2a_JeZAfSRh($vePoTJ~H8-CZ-Fn4)nn z(KA@>f4+nw)CSA~=0ZLf`M>$q|KYOKlStG~YK2*`CUAv@hu2 zPHST05L__&OYRMS*7x%V|K_J{p$;*0*rkG~f3{9pd^*44}G`trO*xM?7NGtqSbbRQa(1Hj`ERpRG2PE&h} zA}HkGm%WfMyM0hcvzGMWQ4%sS|M%;mL;uT56dj$<0`5cAKYp%)^0kwiIay&7xbgq< zH<$39w6y8c?_vDor)?%aE4u2x0*0Z?OCmFA31^LebFq5<+VaWd0gxAjQe<1eJHZ0`);@!ak@a&9KN3 zXESg9dU^lX7%+oq*h}uOhR}%5FyKo1KQo_k)%+iz(`UJ|3vUGPBzrp*X1BEu?8Y1lpYjKt@pgzS4456v&TcZp}dRo_U-Mt1LAL z(&oC9j=G!A(X;uy%+QE4F+feJliU6ILNKV1 z<#@R262vWZ29utYLf_=#0<@)dKyjx)u+JbQNEnqneK_vONAT_qG|g@ya|)=`?*51I z@BPJyoefnU!=xDfz|3+foy_#?14#3@@mY|gUj;8CX^&k=Nl)XJm3>e?8pf*!J^Sa9 z9=_j7EZV3I((3_$gk{;yFGG4miB9l0Ye+d!2nifDS3{10B@`2|j^R<4VI$f=kU6qW z{h;&=O$iGK9R6iZ+_flgp_*@<;0JZHshreOx{by95YWJ~CYZG->t~`On7Rd-HT{Zl zmEM8OUrQjvz4^>cR7yyJmuFCIV{mmVs$D}tC z+V)`p$t=fm(^2EFbK2u{F!T!MJ4?#|)I$NwB`#kNu%h>M0WEDC zoJblU{>H|@AxejMf{QnRi)R|AGcSXdO2I$J(z~8T075@K64`-6g~xXXiX2x!9p_-- zE*MJs`lD8;>08m1{`v^&o&o`%_pK&J8R)Q_u3ZK47`~Sau1p;BcB6YUAhg1P%DwjM z*&!RSwtK{;_a}fY$cd|MH!SgtAj9LapE~0ys#2$&0Li6nWRUU6jB)O zm-U;l&aXf~bh5C}NFlQHxrRNmQ}HvL}GLwW}2B~&B! z8MDs_EYP8fY4o6OH6shD3oL%U1m}&|<8~}L?4FSU)?RunK#0>wM_*n0<^xKa+@XSC zMzh6$8Q1~H&e|NFYK-}+Sr{mUZyk<~KwVo1=yc}VVFGzK9gc$z&RMX+OIc#WVwnPp%D^zJLx*8N&6MWvhT*lmPKy3F zpY?d%rgAQ>Y5>k{2fNjdYTO5j>N^{Ne6;&|~1h`LN-#6NxT=Xz3pK zo`X)Hh_&<-w9i;;0qNyw_ZmL2$jIUNH)m>)%yT52`dtQ;G5=C65B zGP9G|i%ej+P3=d>pCM74R)OL6vY~g<;jaLx3$Pu}}XfNP{`#z|$m!Ul`f*h8FYkoph6h!rGhe zg5C3OSNE|eN^St@tKbN0GtC;bU(iTIim}Gf0(``D;4jlZ>ui|lCNPjGtb_O^8?N)A2z z08AJVmawUG`|8fU1~}0C8(>Fu36Wz%-Z0^E1D1GY@$td&drKP-d8P-Fl#P4DKsL^hb`?BQX?VIzWsUh2~eVU`&y&lThrV{RRSd)USxcSoiQ5Tfk!T=Fkzf|;U5xF z)1%_*5E{>zC`~I6y#M_G4z6XdaKJGyDiSJ4T(Vc%i#xz6dc=Hw&)IY>vz&yo55&Do zhoaBs?p{RXxEl;O#dx@%XaiY;6QAi#;E!QJ*YIz8hClV)qygB$`@oMRg8k+*&JyhM z?(giNnR<#k0$QH)Cx2mQ8mE}|#!&I@iFH8VBa62zu6_hQT`-hm8IQpP0b;NF>WC~& zeKuggfLd3NF^BYI*3c&;YKN_%-&YRP?zvR}t%nn(C|iaO5GO3WlR#v4@74Be2JL## z*kQEZAvlun3p!CD=_!W55%K}5UIxHHVO4jIX4GDR+6HywSPEXo2dH&v2b*{zPNK)d zbqOG!tBuR1OXF2=e}HUY>@`n-##2Br%r`5)*}IywP9HT_u5#L_Z!zen`O<>9s21nRH7QQfjW zGzl>zrz0-Gz{Ao4Hob?4mx1cY9uBo!PBBq309*PUIXWX2k6`9RiUG(qpZr|^ ztu)_>2r7v(Zl$gM@>>8%w=cJU>lNA}*c3lc7HUsZf<3{pq!o$Ia8ok6iP6>TJuDop ztk6;MinsLl=YPAhF};k5_~wkFwe_1lpHRpoo#}yg$`v58*H0^RcpmOPa+b(|$48%Z zU*we8`gU~*CU?EM|4)u6 zKRq6wG};zWuA2kPak^|I><`!>bQA1GBy513mXQ%uzKy4?2FgUv~FDr-<;ef-W zlS}#@ZATT zQz%E>s!QgAI)jPg`U3?{Tn%x|XgX)t?`r4FN>4dWvbHv%GV2{6=#{nBg{ z(6R~?jvB75nARY0^Rg&}O z#xy!8BfHJN0*v@TY~yl_*Yes>Q_P;^BK)_eSV8E>dL=s=nQ@>SFBLdpE*oHvctx`} z2{dvnGMhoA9J_fBbe{z7fYonx6nHeT5Mm-=n=DkA75*IT(_NWRWAH9|Eju^0ZX+V|X{2&zR z85%Jmjc>T|6QD+I@LSgQIdSGg#%tplRIs$gIWlH}<4D?%8Y=*OZav{k@yU#7s!{p~ zQ>ikd%;KCN7_S{nbiVw;<1qqgKI(a7BqpnInZL7ykz&c(M!v~ zmB)s9EE9!>p;67U$=3`&eW8cD_n(*}_fsxk30uNSE|7*&@Zgnpq&$h#{%@&W~aT9 zuF}%C=F7lk!-9&dKs9)e!9+AN!Y=(eF!-CG5brlKN9 zm0p9QSZFG}3rO!E9fE*>ihzpJt8{77JCUwH2)#q-p%*CuLXtaIJm-7v`R+dEz5n<; zFM`QFh`1{8#GZQEUwV=x)hkbrw zqx(K~?n}r3r=*Sr*-+(n1-SPgx*$8i*y)_3dMe9{^o}m;nKa^3Kq)KS$3!_Ro6bRg zPXvywM)!;N>zPR@hCZUmX4_Byv@9g#_TDT_&ni2e@-{NaKbZ4-CE#hxJqCR>&ya>q zHsW5Z4Mp=EKbE7%zdi!K=xdOw`JW{k#1l%Cr&yJlcVk$jxD7Huwhzn4{(`cr?piNw zt~W?&!ayN)Fvl6(RD7S3kiH6nh_}ECmK!91A%SM#!Zgf9YQ58iLeNQs?M#Vc>Uq>0 z30Ul+U{aFi;EgSuu1Z&99N-QK#TMff0SD{%wN3hI*BnZAo zn^S^WFDh^s-mP`s*QQX-TF=f*{OVSh;(snp>Tsj6xOcG#Fy3{<(&cE3 z<^DXFdbk87y%K};cE-Vf`F#b|*4(#7eW%G9f?miF1pAtuq%+^u6*cRKw%M(R5(TLE z84UtJ$Tq2ty%Xw1gH$lGU!|Bm!%J~>7rc236h3Po>n-Y};{GOEV%2YDW#2oy(;CXe zz}dAAG~85>MLE>Oa;7);6F3{*Wj;m^lq&Ugngxy=Rfp=orpLZYlCe{=$rLA!({a#x zmY$@u-WVS+1@9xI00i4iocrQEa%TOMVj$$mGD}n}Pfvo;Y2h5`2A3wNY`Wc(Yp}Va z>XOn%qTm_i8#DiUc%B@;WRtb2PO(N(hff-vek}+6+CmMGBR}^-ko=>kkH@-fd;?X$ zULh0cisxHxi?wy9TN>G+Fe|wYylIa2OP6r6?)jx`F)i!BO9U@eb(al2eTsEp=;bmm zxtu)f4xp5aSxx^6WDnd*rCn z4Y0(kJyuc$yp#iMxtB?PE7>g{f#MX~yF0-UBVtQ|fiGrd4JBLQKb|2Ayg221waX-f z7kUjWuJv(^tn)u5^cgIn`qPWVz`iu_L5a3nnQYPYE97jyPW3U8q+ku`5z^;X3EAB{ z6CDrAU$d{`ev4$zALrD+ehBkevaxRU|*N`oH=xe|S*P5bVNyoYxf+nco1J zG<0?OWXa@$$o%NnM?)f$8j#s`fg_JRnHPauw;5_7ZNjCl1+WXD%1c3ipzrrr-xZ;7 z;O8XkeaMKE@&MT!ohiVQdoKARB%4O(c1STamppJy#zBwd$frpZ;5nw3PZUWe%j^}9 zfOn5wRG@eLQ~hIKG>yd1o07E#%srM~<3;zu%sG1KPJEM+F}x>jVVv6O*H#*sUp$ z-u@38|MlUs`V;fn3v08^N4Gkq&B6TfEu9jJCwmbR16LT{@A;k|mka%EJ&+Fo4;g8K zGX5+^KnSh_A+WjP9{zhXKa={XkC>@!$w!A7O5fiF_s-9Akv5lK2{633Y5od%VPXXG zBa&L*bq@Mz795D=5}S!MS(WbR1^c_op6d&3PFF7AV_d(31vP2A|0GrXG!SJk=l}Ul zXCCy43nM|E&PvFkMSbX^CDC~r&>4HdEP*VY>X6asZ_IHf(K!auIr`dyjy#>EfHKva z88W{Gm=>(J_}!U&MZJp~TB4cX;yCnR-&@E5yeol|6GgwJ^FaM43j0X`ibW7u9O>{_ z=nYvti{=89WlukiA^lP@38?t?eq}7#=PW$Ia~W*MNG8DVB4m70>Ic-x?Ze}AK$*J4 zw6OU5dKC4MeQM?(T)1qv$P=T6E-2F~bV@)T#?K0}&I2F%`N%4? zB%o7CXaKqkaeH}?&+7ny1sJG!E1sP#Z8Cva{y&06NC5u#Z6HOUcl(bVqqqyo^=7Xe zhrQ@e(t(tJSj!?Mux&tLPmmKY<1$$RbbDZKX6yL1#HjsG7-~lj;b;0Zz%<0u3A(a9`&6^P7Q4 zL*6fzmNhbn_NGfq<7K&^rpfw%83@xwf&pkh{}63kHk`5GlfZ9u$NOM0b9e_Jkl!>j z7)k-;XSBW~1QP@Ouwp#8Fz`O8hPF=#_TxY~$pm!Tx}huW+@}JWa&>npC;`(S%Yj`H z789G9O{60KiRF^Y+-5zWu%KL(mQHUq4j1pfaMr}1_z?3@||E+k=krp zKqGt;e!chxs_;#mneqRC0(6#}@)5u@E64>z-Zw;()lQdFYDydYY*$x6**9(OBS-1n z^89i~M-1&2Dt=;e3Y30WackA~1Xoj-rk-PS1?UX7cf$7|>;Sk8>&b4FTJ+Hn$@Lm% z@a1{!1kiMp*3ft9zk>&8TXArKW5ESsE47r|7n$IciD517s)aAL(usD;X^AE#3Ycojj(7CB)1w#&%VD}%#*59(%v?trfQX;oQ=+MR(A2*w94hDnE7 zM>C*mUT4Z)TQM}C0kr9m?#-yJj^X8^?Mtq>C^+KFv~7f0=q0A+rs>gDVqX8%F;z*oS6 zooAEcruk?7WSZXIw-P(mKw4F%On?srvZn>E%r*wlA#F_+iN&-baHY(z@lF{~K4#Rl zt2Cts*Ol5NKsS8r%8Mr`9%%qQ&F4G6U_F9RS6)Kl2E$3Z-hbKwV9rcKI*`7gaz6Gj zeHa4}lV>cmG3V|m3W7V{rbD{HIEaJ`Go-p25Yt^|cjCx0JzVzQNr>s3Hd<1uhK?k{ zgJ^q~1py=zpt@wJcGA6UO1kB>7Ye|b-{QAU2n%Lfd?BL&08V5;#Zg%>n3B?cuRkKz{u zIi@nlAabOh$)fgqOT#L1?kYEr%2eYv$7f7=1}#g5tD^PB2DlL9X2)aqPH{{VxVk8E zU85Eybkis{f!`M3EHpYm2_I6oA%{kq;-VL}Rrlqf6HqlyaRUSC3(SR$_B=r93^bLb zIZ=v5Qr(_k-Y2CB3OrsX|Ge$c8?-TG{g^betoSDMK+ChvJ^IlyeNtQuuJ@vp)J~u3 z48Vq>Vh^CsiUueSQ^eJRv%k#+FJ@4x$m~CdG{upK$F_pXa;&~HXeKrTM8w48j;5iH z%jIY-W+_DmJ%HJ8Y+*F-s}woGq?+XzKqKjW3C zyVgZ6n;Q?bbogl01CU8idBG{CPm!wV6vGJ)Zsfjqd;4B3JCC7&|i-<;4NPT9p3I7%>qavD|_1@ z^@uncsgwWHXwZ_ZBB>ue&+vb`&%>7#c^_yo%f#!A$4Gw#Eaj#>3*h>E13;xH;u8IR z!Ij>qPK?}J2yr69Zp1YPJOWjHgOlh(LG}#Be|j}|-J=on;O#;I&AbM{&bx!2>{jzI z2I>Y{dRUNvhKB&*u%Ptk2nP~SF8$Hou0~vC+I>7SipT*8dwO)a1N+Sy8udRi-bgxO^$?A+hcntft}*;V7C> z5*-)n`Pc?PR^0Ir@({GcST_NLlfDfAFd!U@S|+dv-6?XxE5(l;rGGPlb$YR0|_q4$2N5((iU)FAK=ee9+X zqrT(7kJPECr(kNT+3IA1P`_i~utxzf9kc?s9B2fv_KMDTL5p`|kq!Xg*S7QtCjd}! z_pJs&f9z8NFD)zlzq(otrVvIhw{~}=5E%7V(4nD+&U1$POT+smS9d`SrITe16}(EJ zkayYsC4p=qwha^+ZN3O_)3Pc*JlpfD&F5g7Q%$M()Eb~QaK=f}l5-wG#IJXQK}V;| z8346v_YVXesA*epZ)d1b#5CxYpNCM305sqpO?j}p8i(hs%YOkwCPzm)8kohHK2i|} zsjMs#q{9O%UCUzRtWnlQ5I$bN*ai*YKn>Yu6_v}4P$w@tsUa9()3v2Q>(iypJkGXk z2!zD!$h$*8&?GQzEblG|T+ywn1TLl!z_ac`r%PFhjycH1JGF5R6QH}ub8?FwCA9bE zz5xnvC(>@b`3Cr<=Ym%%`p?u z#vlHOgfJqPrL;1qn*zXufVoSr5#{MJo8cn8QZWFLo&oVndnX=?AlmXbLDFpVW)8sl zTfqsU%)l~w4dXaTdBT4lS^O=f_ygF|ILiUcn5mfknwWvYH*^vQ3#shLXVGOqz@@?@ zma^WM!}lK)Gp?2NDr?t+xXIwuCBoB2(rYS)$O@mNYkkMaWM79jV2Qlu+b=B9A+Rrd z@I4$BI)(PutteA%t^BfV3?OfDy`A7^OeVeu*)|bo)@T`qB}4v^a%;`q!*{&koK#-} zFF`LwtHz@CLo0b$51vf)3Hp5ivM(msdL1AWlB~ujfQcRgEm5lRQ7~X%Z2Bom$13|l zF^3E|Hod#R5Yey?;pM<4KYm84>t<*t#|8u&!uMU`hjB#`BFhEE@+;p~`4G-a@$v5O z6~h)??B4xEj>Vzpzn{?i znN_O8&8)Um6XhQTAkRM-kX@+x3sNh@CTGXN+VJQ2#E+Mjs82XKlku8hP{@o)O0kxS z|Cwy+3nwf4r^t402HhGE^Ev`+*aEQqi~wiA8NW1AYMl#iRUdxZZk<~wpE5=ZDS;wF zHtz&o#E>6uW~cA0ruV@)cWg655lg7=x}5cmXTzn1=%alnBzzQ1yc;+%tyygH=5uj} zcH=`!SVWGhxjYMKZ`{zvl4)=F83XfUOoJmirDqgW5WXLIRP1o{?-NL8l$eNFQl8J0 z7-DNykgsXgO*)#T6NZ-BY>qNC#{m=#>~JB%eXlUnc;h`ExKCp}Ro(71Mmb^rtzAyR zx#iqas}ep+6y4!oZ^c@WuNl@lMt7;A)d+XDH4KJQ2K{#=el5&x0>=+-vHUsiN{}O{ z1tdwUh;g*MV~I=P19&u!HQ#T(QlG5NM9}ub*U?6AVBsg`fF56pS6S~WMj`$o!k6|hh^)k2fEnH49`dLga;OzH z*-_Vg#~vomo|9yAVBqj5!MYb*)&bBetOU23on4&3L94)r$VLOR#b%S%)w0)a&h*&1 zk;F13Q5`-(B<*#=0~CC&UvwI+BEu#Z1V0Z0xBzF@XlZ&K2frbwEp+o0DmPv=l^uf1 zdg|ut>kolNC4z(TEJZWNoCJ;N2Mbhxl1rq7tijHhNlRTMRSWyCKfYPt=z&@ML=}zv zo6URgp~x%Chtp`=ZyL2zQaM=Dz;8yej2jDiZcc7pV*$~aa;-;0bMXXu& zb6<*KSpGCeCob`~Z&AAw%~pzH7XCZ^=L3n2yofBqPmCOblP z=hkk0QmXR(+-Z_HyH{B9mbkXtVxRLa?rlee=bC&n6IHxiQIh_Ctp4N*Ym~l=oU7hN zDevj*BaW@(bf%b|aG^%@bcoBF^*W-=g!eMuW&ojPP?fv&Z3^9FX-*VRXe-0-PKayh z84Yv0yZu^Zpg;N&fqoG%>;U@Eff|XFi8dS&_bn1~-!rjuZ7lXQj76S{DTpv*Q#{fge$pqAkIOp} zq!l-|Cr+~R#j8y9+@oKLr;38dGX*~h{6!o!3D(*#Z*Of)@&*Z;j4B^@)ih=MbC>c7 zg2w%}+j z)QLTrcBGbAi9;OHsr|ftp$E3XaU=$ynWF_vzL*y{Q(+H~zuKE*yw)y&vFx_Co}Lz8 z#9~;(K7eWI^hhA@M58@f3w^mqOjA}IZ0r^nsQC7+?M^TAZDpp4xr;6I);r#|+x>Cq zI&|BsrAL7`5!P|^&HgY~?}d1``NHn&<*%Ga-r@%h%|nNbMw86%a_iarZm$0CGWb7` z#mOH}SaG_$&vV{46(rVT>+cW0&#OFmR5;q{`(rnvQK0h7c(mRmkFBqSMZwBePfi=C zZ2%a5co@n#r4EWpa&!+<#i-q_3K~rkD*;YD(>#6BSVk=>@)#T(r%PFUHL+`Ja*X=z z7Q>Q?UFM#4#Mihx!AvfO93y3T@t08rlAv-SR6Kc2^H924saktf{uhW9Z3$(=7#d;) zyTJj9X&4TM2C(-u&)@j~&J(t@sUXC<yXaxvoC(9TBbKEqhSL=dKkzOvavly#oq#TtQDbAk|EMdK|<8d-J;M z&4&5a*O(H|y{g`*Ia|zlFyV;_s8}i>{%GsveuYVNwDI0Rgqu7CfMWrIYtxUtrRAwj zmo-%Ny6**|$7)`~;!KzXKYb_95xtsp*|8XmzK-6fRr_DnE+#o>V!pwC8YRflEL{7h&W!0fZOuxetsUIxl=BEQrE#;p8 zX98(P4?BSC8^g|PYKi36)*069qTPz7+JcD_#AlON1A^DDX+|F; z`%B}v?=v3^X~lf?(OW9K-0JasabxD70M%qd7kXkosodcwP$hPx;vSaCo^QMI#qfe9 z4XeRcx$X?YzAjGsCXZ%(BoFVneApqcvJ}1{w*r8eL9wefrjqe=?|?}8ai=6_FH>AP z%&u-V(VY-TeBKP$H7yclpt|N>>!K0PQjYg=eYEi{{{5{#hiz(QpqXPDo-_a@aI%4? z`*b$=X;2Anu=o=cy@a-#ybNCJg>nhQSY=rD{TEAOnu=WRS~Y$4RVr|WsVY!sfa-qB z4K{EPln@=4#|0+SHMgS7l0sReI?!NH&VHt^7&lK>Z2AEcTMUdn^R(o0U#dwbt@F91 z|CcKhA$o5$J#1x(Ts3sNm#VV4PMyAO78Nk!DDorxypt$R?-_gSYL35f}Ogl-?au*v9HPrYifl2uFNH11rvWdY2NAt(PZ zZsmpJ27e%>YQ;Bq1wlyz_)e(y6UU8j?kz1sqeihi-(KJxCX@Yb!GBFWZ8x8f)am4L z)UVQa*fccmGM6iwo(3n@E00h8_gMfTQP0*Khhz$W+@bnppo6IZgXn=VS5MF_cZrdc zdZ@40%)dlx{j0r|<)NVK9g26G`nptbVSLxtdm9*$od@IH=V*T3Y!-}|LDS*N;#<=fb{ZE}K90MNNF0pA4O8GK z_TBJ%)!d&DJfi}c=D&FwRa)`Fw^068(o2qWlVK|`` zPq!N$%<9D@2?_^wADk;Zzckity?7fDPE-Yl2VC*h-t{2L5yOI6eQu5NfdNeaX@Mcn zkWk~9wPmP&UB@aS)hV%FjbSG=}tPWGr<1X?yPRw+|aIY+S%_4KXANdC> za8F$GWUf+4z)9_NglwX!S#Ny$OhISAkEtbPFI)SJ^lZyS#W8SPwDxd3i&=QD^2*xdE<^&f&0T* zwMyVtjc45)dq6z2rp-*P7zjdRMvR`ry(w?Yjg8%E)^{999w`oRk|m4OmC%`QnToTQ ze=c~9mgstS%6k(Z(wJm9&^8k$lhvshnvLSL5a%v$+HR;EKI1lQlyfI~>rLj#CKjUS zjq3G+sC{+j8sb`@`4E}@y z!0=(0)16RVtqr2)b4i`nf9-x zw!PP@^6H*)$LQ`#Ag}H};I)Xk13EsKPMJLO65G-1l5os8vHASq*r(M@w&lE9&lk}q zyIRhnpTEcji&M_Il49xqy~djC1Y+)+=D8)Gpx=B2Ef?T$7wmon&Kq!1B3X7aeNv%P zihLqJ}%8em6z_R~3ck z`GLf}bL@FUlDL2TtY}$jnFvZEA31N*DUbh!tei_qLh&3+D08yyRQ`1MKu|O??lQk2PibxY6)Jg9ZGGc1 zpd+l?Cg#gaj5+$Me9YDU5Q}sJiHX7m`?Af0!p@PL7DtYq&ab>6X%cCO9gGOXtkBs$M4aMxMb zR2Y=IFLY-*`6hPQL2?@in>7<%aclM2Od4DYmStEjdc0CN>iXfpuqxd&xz{E%iH`8a zfeYzfG2@EhV;&`|;}FC)zOd&hiR0ja5HQ{UZt5Z2vZeNKc0`EB{91J2JOCOB2(n5y zCW5mPQjPU^UyGUB4Nqk+Do`GQ@ArSxi!M^9FR|(W+W(?_Geei49&PJ5nkVvRjVV`s zH_?*5@thEgz;rb@v4d87=$onC@cd6(&h2Rbh!0FfVa`Z#b$r5DZ33A&O1~I@6&Kse zmHrJB4%px#2rs*uFROH&lM%&=;yf%eHV>*w4s}PSm{ncjD?lH@Ojt z2@XJ@=JgD65m@mF{k6c~grK~h4rg&bZB(d)MJCO3mJC?0U%^h8o zW)?Y&yCAWh^8g1**(x2P>tkSgI)oGPCYDU2=5aA#g0SSagfi54RJsh1?&p>gACf~# zoD#|aFJ@v@#Q?qKndo-_dHDQgJb9#QY%O@MnC;5%^NFk=x5dhq2MLiM z7hrX6(UE>I>O_Xj0EnAn3soc#xe`#3p%=S}zY*nsdQvD1EH@)oMfIDTSHM1V8b2kE z|FmcU>ml78gh+jmuPPurJ!nx2|I<OOW`o5eetD7Y@?7dV1(pka zxj;{1!?Q=AcbTd7NSYj1WRoj_PKXSC=;nofn)L|0-dARg1hPm#VF=u$+L%`it=H8D z7FUu!ny5lnI28*ZAS`87BFW(^27*s&&$7wFfBvtrrG753dLDa@A(>5=O?CyrgSC0? z4k>tug;ZYf!twv0{hXlykcU-!dcOrE159)~EY$_K zFHCM99ax%nGOO45=4Yw`cFSJ0tX((Yos3}K959#$I%rkKtA5Jep34pRyR zhoXt@OZ$7?8w>*QhF2E-MW)-elb;w5`+lMcYdF?WjwJZy9QU5h;Cq>2&Ps$U!qe-b z{br$-f(+i~0XKH}nhCnrmDjC3o7XxY;ha&$4z}xA24&y$dR+|V%D+OPg{r`A zrAAa;CNbDTD|sX!*tc?b-hFEo%XIvKA7a?tKIw$QfWFs`){>^a`Cdl=s&*r(Vy?_< zsdTZ2N+m~Aq?pR?zjLzIMDN2SV-N`@4l89*KIDThH6G0qwaiztEpgqc#@D&e??)BO zu8L=}oh|Mh5vj)hS3KY>D}G+D2h+z$sEt|gd(xV4-mSX z`f#>5SNXr{U;Q~m(9v*2x|BC1>rEDn4S=5BgY|`rIry@%#RZQBae?a$Z*43TQf6sc z%us=+qu#m<>hM6_s-Ukex|L{c%{jPR`szji_U$!iL{x^kbtm9+reXdy*=H?O5T6+f zmQMeh>F9U>>>p$H@&xJ2EExzxDM5guI z?tC_0Q)V$)OsD6w?No#%>TPVaS=+t!WAlwIy%`ACnfH$?dksqN^x$Gs7y0g)Z$8Fv z^7X$d0!uV??vj$x=Wq(zw>gA^@Z4Sb@xeDr@ba~D2HJHaU3_(KL2pS)vT~-Z^6`QM z;?*5AC|x!bLxBmiPZMFz{?@TaPeB zN~odo-ES)&BFl4vZm{FT;XKIvj`q@l+kZCf>q6-WSjU9#4`WYkb{)e;uW4sc(s7M2 zN*}a}?WS!NeH1rK;_2ZwMq0)Jrv7);B=!(9*3*?f6*u1(6*C-J(qR>=T?}#*Q(v?B z;+y;0zzK?auGioY6;~Ljl}Ce?^B70*M!kzw9x}O6b##1U<(eYkwr(02&ies4?oG7t z&`IH*&Lej-TTse7^c>m{!^bO7B31lakfP(4=nb-*MRKMmFB>+s6Ft}`+?Q+bBsdkv z0(gpoToU_zIGZ626FnPTD9a(dM9|!hqRAv&ieL1sG2S#D-66fsSIKyxw+zoF5<)Yu z9J#8p8a_{uG`GT~%J}J=dEnQ`?sR#%tfxEsUK*OuByL1meui4Lt^V?A#qN2PZ8!K@kjk#4NG zb$LP=ugv%?4s4vvapC^I>Kj{_)>^1pY1s(2@t&^eT*sUF-xOEMvAm&!U5hoUCZJ=0 zC2aB4#g=j*C)`0F<8wmbMqrddNSqyBQ=>r7LJFkS2+4z4|Jb>*b4OQ*vs;^8sVel! zncDW@65fagM>q%G;1O1_{ZXbioeBys6C0UVN$iY?l&K7oEro`|aHp2p{>^O&J_Ro< zzf>hk`tk;ZBRO$3(6+OBqwNBICOX$)?tD}Tan!lhkn7XRwd#UkpNO~}Yj^0>w)wE~k)&=h}@EUDjc3Y!dyd-TC9W!@_g$cZ`A}<?N`a?5&Sd~N&wCm&*=#>8742NVmz+0@h;+d(JF2)HMt zQfg5^$eh0fu$Hb*!#U%bqNrBWyy)6PR}Z(45qQp8x3BSp55!ghSU4_ir3c?K-y&e! z?8?dfsipkhns4(=#Kebg7(uIm@MFC$T*YbqPNuSR^U*Dot~vG7IiaxZadu}D#E&af zEuil6W9`X7YQ=alI1F);`qTbysZDoLBIpkxS}_M`3G77K&ssW51r*U?lB3eC$dXBtAi(Uo^n9HO$$}C$2|3sVABvZhM?x!S4F^6VB@|;2Hfv6T}`@ zMWmZT9g);tSZx_C*3BEY{XFE^9$JJS$kV~JxJ35cSNv5$Jc|NV2$_%l;-K+2-k!$sh-s98nEx2$qoxZQ_Dj7W#%9#kD7WOI5R>0Og{>AfM z-pB#V1u>!R53{x$x47~l0o4=iY&nC822Xf^bj+5{TNr2K@?^Kvdb zZnvZ;C&)_gCKTw#i#TYx(;ZkDlk>|c_l}Vr=CdaHUGRNJENswY)_ z^PelPJw|u(1den?Mvh4>_az4QF0#E}_xk30C@CtbK^b`7-jcHmZCl}LGv<>pJ#9lw z>%~2{edN+9xmDqbQLTTUV%Q?ip!Xp`VXBp-Y`o@i0q`l+dZ%&+Eqy3m+E$t2KPC!i z{|Wglsh+t4Kn`JEZ0=GwC0CNAXSPtmEyw6!PfoFCoV9c=Lm3fBcF44p^H3gJVub}O#*m3vwdbT(}y*G1E@GCluZ1~5AkErV!O)w(% zoelrt&$Yj`D2SI9->Olds&B6)ROshc{jx9O(!@mGMe;R!)(>->yCczTR2u4Jvb(Hz zVJ0YU{jL4|cidwVfxWJ1mpG^=53Wh}TJz;j^xSQ3*e{8=6IMNM)~aWkKDYb{@oR}m z8>VU$D=mopqHT8*PUKzkd75DAymdSO+$*uG3^k8jVC|s_n~@WxAnHvF)JlZ!rtfL; zev0&0+UJSMtKPLL#ET$m6!x7X4!CJp309l;X4opV=O}zc(mG8!-7B|tb!Q`Y^sAIT zBq|moeVeKH5Ru@}nRpk_BQdpAHj0PpjI}s#8FvejRDDZyFB+-uHYP!(tlx!QTB%xF zE;v7GSNpKmt7f~+cP7kNI{HMyTa}EM?cE{UYIl67+m%rJ5n4$Hl$K|9b4ZRUP8B!q zG=p?&38}=0lt{JWz=(w>JP^#mhv_L z=uybu)14*O8GtafVl@oMj-=N*tV{FMwJ9^&l@>2;FU6n-ANsVW;~4DsO;c61*T=BN zxG}5=ToUv&Ox$^GV#~G-(y*y1wnH2CPDd7#0tQ3oTS~;9O9|IEz90gTy()^Eavn~- zcrle&vuk!)v1)uEt|e%>VEA$G(q{%@LV?>Y&Bq6l9Q_X!9-)2EsV;R%zXtQ)#j%WG!nGiH4h(LF85OXK_Cx`9HLo{z;!>{&F6B57B0*kn%4%IMlbV^CG zKpmo2y4TBNe5br0H=&5>S&x@?MoSkX2V__VMl%Mud;<>AjoV%(pncLwpgYew8-spI z-16IBv@|5ZX?!ve>~3hB#nie(oxwpu8v6M`=0^f1iqzahO`Jw~*g z&d^=s!l8W^5hkwffng!ObfCXLY}p}J2h-V%j{3?+q%3n-WT&PI53D=S=Lr!6s!B75DeX zq26ElVImw!Vg05UkxSNzxI7%uqt%+h6LC6y(b40gf~C-oStc z7PqwIo#GiS2_W&+Wi4rjR<7g z;s}Y-(>LDa?VjoK`IT9OA^`+cs6%-wo4z>iT_$RZ88SOa6LV*%{L(>1TNL;^nWLe)#(8=c`U`P6{{f ziM>6`RsL4(=@&J-%jfP~`{30oTvd6ULwS+88}{}ELbQLKi1%Ku?sOYikuEkj6D`Ij z4q`X?tyf+4^Gg%0S8Flx9@u>m%UOewOYbO*ODy>dO+QUeoxQHO>@S-dME67O2*=sfeg7Z}Du5Z=ti70dppz~A; ztkdhV6X(krl(J^p3m8W31+3Spf7QrdDWIL#zwsdFzU8T5`-69MjJpr|%$3UfCl`W~ zItr`rQL@f&S0Zb5^OeeriUY_@UQ8usBGzL`W~5;@37e! zT3cM}IfJ;!-*YBk1kYU6K*bv7aVW03V^gW0iE7LpHXPc208OtmM*cdDFRjVX%&+JM_V>a z<>fDz*XUTXt@&gnWmdbbcK*V>rDC1O93DD{3L(BrnS;#VDowrq77c8|skc7{uCkF- z9G^INcwvzrV}gWPoC-b?5HTw1+<%_oq4U;wvQpzRUo^jmD-Sa`re@VPMtXgD#Z>@> z>vz%$kSnq|8@^u0olx}Gk>h7%|K*<>&yV;A2YMe9lRA3p(o5Oye=fO4@4$VZe{He2 zCu%$OERpSM?+!A|{)*1&N5STO&jy*dS`9T*Ho*N=rRpm$B=fS;8n^K<)i>*w>TYZn30VYpjN-S_H*>;<7{LdgtNQtfC9~0}SDlZ>io_%vcBJYFvMr zj@s5lbHCG4QVDPiWfCrFR9+TDEVL$#t=)3cB1R{k7_X;et)ktATc45(HplNr5zXZS zCA`x_Xu7CZ25+j$-bB>Pv#U9Wu4zCzL#Xpa%BsaVU?-zus@?ePv}Or z(#?dxWA|O}ePSC44>B#emqVbp-gu1bx}+(&Md*K$fE7>o= z?=`(mnH3rrTEc~7g1}it>XLpCYrx3w08%a5LbCWhX5*>0` zT-_IaeLtX-u4%KlYR72=_j48IE5!>THEsE`zt&Ylv ziH5df$~9Q~z4BJ?noJP3Rnz=EP|LVI_OqW{KPxn@&mC$l7LMT_V@ek>85*m3z7O<= zP5oc%B$TJ^=XWgcudWIos30B{+V%gS{s52PuN!n&LBRE{prapWRu3K|IAIfrrzEIg z=G{PHFYbRfDZTYPhaS0tX#+z{wttP&q~^B{wuR{6)x#@$sH18}sY?&D_Px6@`X3fl zeoajnv_0IYC5|nwU(ZvPsaLDCvG5J=zJ$Yu(2wG`FC2U4M{!R-q}45HIfN5Z*T4S1 z|Ga;2^f=wwMLP#x()XNvvK#!%JcRJmH{SUef6-4lBES-<8K?28W;yZi+x%-EY0VWz zMZ5w6T#s$d7|w^+sHjBS7#{d4x-Lh>TcNg^d49VU6pSx%Ojy4d^hDi zcBPk!aR+q5>OWp+X~43&YOU{ES{VWaqh*WPoT;HfX+-1mi zT#Q+&@8yENkC&Nee#6u$nghc4s}j9-`;Cobsy};Zd~*o_9sHwVKYO~Njr#>;>`5OKJA zxWD2bYz3R}Hp5M6k89%WpRc8BoVI@9ek@x@*y);*TYSxNI+r027Pvv2MnV5~`wD5H zgY3!5pY7)PL=VPA$@^%-@;J&U-VUDuM%$HdO9T%vebY}-P;QGhVhAqZgt6@;TARw# zc+Hgs;(h|`jxX&p?s3kK19ckVG|3lDCiSJe!bjTV6vdvz(K_Z&$=SkBNcgP!$}d>k zVs{bZs^_KiBo>aArYdffd^(*x-}ei*pC@-=85>jf;JiSoXSRlKUrN(XvC^@^HAzXB zhNl!(rq6>W)#}7#Pr9I?GrUs;7do&lowF{A?I@F;yIMKh;C#zA|45ym906PFQN6F9 zI&u5tkZl7>y96T)leZqsD_4IZ{4RezP|}kq-7YvqhhBw+cz*N@EgzFS5s9!@7d>{gux>DV6xDlX(w_D~s*_S=1 z@lg5l`)7?dW`~z0=wK^n7W=oBo-IG8WR<6+SPI;`9ha|ZV8f-sa#k-X?x*#6{&C+W z>-8TPXGD?y_%Mb-_jBh?jw(&cBHL`K<>xGuj;$(-#8UBWW-{IPI{Sz zk+83q==w=I;ZqW`i4)p)e5+OuXqZg9x&+F;JQH)64?enetFMU7zn3d9STuKCnJ?N( zOd;5K;ID8I;D?h^YS$}JiE%;sK@(oO87aB?92Z|zdUa)8;+{E4H?ukXPr+o0;qB!m z-l*vJmS^2g*9#3y8f7YUMh);32Q40ceaj&%sa&P!Xw>DVEV$-D13Njq8l}JS7~A_k zJm_Vea7w$y>PrdXxlfVERm>ByXX&`vYwml)D|~bPgXq%WKCY09SLw<#lf3Q`b{hYw z7VB~7m|ATta6ahl{+oNV<^q_ur>Ef#KW!zUyYZptb_AJRmxL+`Jqp9j726M3}{-v9vTTQR9;m|V5 z_9HmsYkJuO;u-mj1(h&mX4Fu?hqp$lgI$mxC|pKC7P zrGcuTt(*!=@sfhBLfAN6K-1$%qg5p%T#XoAaQ-Ezy9~tTf1ofEdyH5V(K+9)e!0)Y zqU&xWx7^wyyJ?5enDJ@WphoWea1TT8n|vxhy>&GWYIkiG)$hI-RZJ34mD#sR^jXxj zYqNK_C;8&YM~jp@EM}gQUA5{r*wyd$$sBf#p1{QOnkPEGqDv(HT>^1O3PEck~Z4C~FO9|YLBw#hG z+vr$ZW{R5;C-<}67fu@Cowo}(fYoLDxPu)u!knaLHDy>llPyZXbNRZIZLN8Pns0Qm zJU*7ch0wZGjPW^7J-9qjnN2(AS)FY_PrFbxscjdevl|eMiJt05N#C^I=%On^4`<%b zpe$UAFN&MrPMGm6d)25i1s@k)a)LcuJz2RXnDpWE&CFo8(8W@;id|B|HM0i`t%+^> zY!rJagI<%ck89(+RGmnlf`zWKif zfpx8IkJnxI!DL`kh?k}nRSTa6XNR9_>a{ItZsdx@8X2JM*R|z|i?HI#O;_mylGS9D zUvvMEaZrs7H~ZnikSsMiR=(9~$zXF42;ANej#)QB?&7i|Zev$Vt@}^yV$BWsQ>;XD zi`o7`uDd1qQqTYWZ>fXqUw(I?bm4(pfb(rAwRqqGatUqwLc=L!frDs0HEc<QmQodxRhiYY!YVfn-_&b;ES)y#^(P-m1zMH49@7gZ0+1mo6cv-?5hQ@y8|s+a@hE z;t;uZypFKzrF!1J%4hK;9VT{i;U>;MRb1bzno=`%oDPqXTK80h z%LP;0i)DS6V=`-Y%NE>FStlumjMiaETb~sZ2w~&bb)NO)Q{#WwZ#=H{!r)bA@pNXU zOWLT_u7i`qR<%eKF_HEyR=S&5nRmOjQ_45^Fqqv?k)5PrCgitWiL0J=vBda$UIsHp zX_%6ULqefLH^TOZ1Ax&L+2UMr)p~nwA3zkdUS;X z@i&$c8mZAsI?9*Nj4R*FlD6X#wH>M$UZr;dvyINpaz2SJSw*`-?YDN&)xcKKWySltN{Z+B#Bt-QPITXSzPV@fuxZk$ zo{_rT0;T9)ZBc;7>~{33e4y%-mhR0Uh>tmAU}S=!bfbiHHw*&8n1o2T(%l{6s7QA=(mB#F#61J6db)u@Dp~Tg-ve7ci)6XcQ?!w zYSh#c31y2kPfwc}+Blt_v{?7xx|ldUtVIfLrgvb^VvBQ@;r4aMe0yC(oyFR_Qg#j^9D(%b3L6VBMS6Z|v|qbs z^FUeoL85YO);ZPrPrG7Cxee`g5ali;YdARDdFky8O?yosn;sLnKa+t=g3(Q|6>ZDZ1Gtd#jZUYMn6ELfUKJ&C@9PO4m&Fs`TR{ z!t{e3eJ3hJgc7bAtR1)_$5Fl%yr<|3q3IkO!Ri>S72((!nP4ehA zE=_)oC7#)uD|va5>MzliT(&+wQT#>urQ~ zSCx_ak(?O(;+Hg{9Y^QRWO_DizIsx$gRaQeJ6om{h#_T|pXw1IS!o?WZuDE1r@rVM{u0-`zCdWPI_SGXb8t;WYrt{fsZudQ1Wj~$iO;cTh03BN z@uKb9LR%iX zzAMXt0;ZmX@_fca2Qtdla@G|ivawEl_A>tzwW124P)eC>x_sLD-2u*itNB4@jV8#;hYl20{CW*u8CZiu)c^g9W5gyeqV;1J9k z)q!bu%>XSOEI(p3{(krIR|#On)pGaK$UjV`dwZ^5Lv)T(MrlWQ^Jj{^4Q{GiLWN&% z9;nmTh|Ma(p5!e9V$tOF=gBk1{aJDw1Wt|Ayig~lT2&>~;1Wz17Rf~#k`t?pMwj7I zlM>v~e@%8D?auG(hAg(751>O)XI7k=y@zDC60tPUlyEm3l2@!inUZaaT?%<6+RYng z>lxORX1&%rGfju0@ojTS&0QQCl#@L8&JB;+GjbH|!Ow0Gwz-0#!K6i(AD0TqT13$P ztQX`CdUmfJw4P5O4Sy@4YR3J6>mO-KF4th{sK0F5&Awe7X=zyXtltDr*mI@qhae?c zdt+ClBj)Z2lyPs45>AMyzR3#-p;mJ5h5(4|aw^6jlM>G+jm zy`9N%^-R>aY4e;Z1Bd6)<9$50L%@Pt+z8#_7%;S)P2-VcnzbBn9LzQw$v{*{w`3kE zJRh!Nr^LK<8=u;sbM9xnMvj{2yu{j#u2P%GQQi}lk?I}QpQ1m`j@hnEYN4KNJl=S- zI_lRjCe~K%KQb1Y7I1UbJGbYyV|l0lNyL{Qi+s28ZJNgFRI~%uOB@DdZ&}TjxjNrY zXQGzpaW*Y@ayL}h7SXg~UbDp*HS{T>=TfmgbAuA%?WT`KsC-@QkFVppJh7(bDi=?y zhv^0)(?w8jSSL6w8RDKxo$31m+-HoHH!f3S12*s_lT8szhItyD^`4hX$n@3;ayAy0SRt+Jk z&X+o85Gah%CSY~3wpD1E$68y1akf#Ef*_CvMXo~0r zcv@>rfjTZiBkv;zwbXC1W3q>bBrQQ&QR=2EBp(+r8wgiQQzKuKb31>O$eD&Q4zdO(7-^6*TF5XVH-m{MUg|Mek&R@hL=TD#`oCZIMz zOSy+Dzr6zfb&&i)D%~VhVVuYtgIFkq>A6_=eV3?jij!U%VXe+YHG&1q+-VsdU z+0-{TwAVT{*DS$N?s;Rk_CV=p4`Z?Ymix4*>1oAFQilOMM-i=t`x-&E?o9;ke& z`?M`BoGo+QuZM=0f5MWj#K5-ryX?9Vd33d&77md{2*1dfOYWzLNSxXn(MVIOGWDHO z%NL1)J*xrJ?h>2hNiq&cPg9h#D3a@cn`csuzRnE_V>7j~iZx@5=yZ4>V>XZT_}VXQZp3B|&;wpTx zv)N^j8NN@tP#gNAR=0V?KFcxhEH0*BTlslBug0>$fC(btt@Yk#9O6?`rfHap*EbP} zY0mlD?->o{i19lPG;b({9;kW@7#6Evs-$v!{{_4gxaS5ozUyk^La!;dOX4-s2Weic zVYW55=_;qkiXXW&v}t{l;{AD}m^WaYv;6M1keivS)K0Hee>zu)8k&7Ge0(EV@JZb9 zPjg$9>|I+Zcj!P;MYb5p-~mR599Ho~vc>CH{e;M~h7KlUZhHNWoD&EwKH> zvf{n;hacNhx2~7(m))IjuGXEngS+W=f_m;6T}OW$UN9HIoPK9Bje~q-<%9GRRt>~r zY2RI!iw0=v1__aqhsFJ+N?p?QeQYPt_uTQ`SB6G6q+b<@Djvg)|2&V|clYo`UZ;(a z-04}?p~0ccajzzqoKb4s=qE0x5gZ~h7~_&e;*HWok}2gIb_LBRf)k^4R?C{7oU^Tc zC{rv?Kq+YG+k9ZKFjc6THN zx|KNI@G^&ha#664PE2E4Es;3G@>XfIY@eXarv{?85$4KFg@e5441a@=CQ@(mY_m{1cVwLv7}yQD}Q#Q_^SCR_2H zE$VINCgYrIlh1Bmm>t`&kD8xEV}$FL$|iX8C32Fi<_dh{*0(kz_Ht~7J=Q&sBw>Cl z|K%F3&7n+WZ=Xt%Y@&94Rk|E=1!^-)BLM#=*~Dsyyt9o~5qhghVp))og7=bL`ATtW z{5k3PfLZ#0adGZiZ{Ka|1k#*b50{2UoguXO+NwY)bfKY43GI&aw_=J_uwt8CTJ?7c zn$I(@xVFRhm8G>YTK;8Q1GO<^TshYeiv##z8e3Lsz50iA0M=N(_)b{nD3K)|p|OQU@Eq4dl5IE`qr7&7xa(g9jnuNqLU>tvBy24y!2A z(?Z+YCd59?=wY)*))}{7o-$cH$3&gRIh5cyKY+ow&Bcs6iTmBnv+%=lvzoX~zTLPy z6y@*vk>ld1at+z#`+m-(y&TULnl4+qnY}mh>lus|N=fC_zw^yq;**H?!+KfO>crXk z!J+I1DPL&AkuN|%C9^Q%7b1$nL4HpX+J1KwpZw_1P1^_rt#EQP!L^k+qNV)c>ZcCI z-Btxd0G-6K*)lC}>Rk*0o0~t6&@VNW)*b1Mr#yuz$*$mc#nNX2TR8L=uza!$rwp-%F~-Ko~3D-fHdVQ$d>mcA4_ z)Kjs#RG%dV3S(JYy_G%n`0L_0RI}kS$`jd^A2~pAN_C;d#oaNfXHqX#p6>)MNiNN7 z1E=%0q`v)!E%6QmyX0*}7O|ad=0|o4YB<3Myaxioyb+@4x0EQ?;5O;L=n_01g0_sg z+0!F_v<2@ZW6RX`Hv72pgY1U7jzW_s5o09$tzJvcaq|aP1rjQo=c#fVr!06c&g9MV z&0O_nZ)ld_wyLw5&BQ6R;GI<5sA9D%(5aCx95^!Fr&mzc5gIZty(QkLqv4z_jm>dZ z=&xzzXhsJYu9h`btQN4&BjoPsJE%T!@e_~cP&;|0HCP|Xz_zfsPDL1@-=>n<=^z{) zlI5_h{3!M3BPCsgUXy&Xu61G0^CGpHU+fsk*YLE(th0E|HP<*-WsA9yy-41~y5bAk z5xh`w?@*eLg^T6B3hK@^5oL&#NT=qXW42#Cv#h6W91$8$TWWD)__##Yv6Og9Vk#;G*(uOKmVlH_}iv&u{9UZf$Lpk~DUKbif1}eW3wI?h0!BQaTX=u=+I&r^NP&Uo;wvw5?e48e8fRA1QjD)!oGTfDd4Yj4;!|#vJ96m2-8erk zHjV?yS|`X;#9F~Nzq18#dv~APYrHw<{Z3tEd-F#xfUM1S?^>f!YeQ6VhR~F-W-;chr70h`J=AZS~4>SRtQ!goQt%M3%2C7?mF>^#K zDyUtB%-!tbBD5_N;x&03r|HkyB3vKt>@Z+q#d39-sNGdMKYS8R+ntZLS| zs^%xSqrAnc{K<5sH(jUN(6q8u!Chqffwv)_UJ`Q>-v*p9uYs;0GWWd6gT-KyRF<{+ z6OLQM{aWd4lV*82#(o%=FtQq3FKUhCY<>T{nGl>A(|Ko+xK}Yn&M7z3W;VQXBOz(m zT?txsWc#G|y{&WRHqD3*)2d0PhyUCb_!dCHsE0d?p*TeN*PROL zWZgDkIGpy^SEL`J^Py>)81(Fnftg}m+rG8sp0dF(@u@V?AzNNK--P8!r56jjhJxQN zLp+H6CQ$h$)3Wurb9RIMc;XJ;OJO$7)|x@{}9U#hau8n0(dXk@^P5WUVk^T@^?W0N{+ zdZ~oW1o3nZGHl%jEN}euDcGL_P51n8yeiUEs7yBVZezwK19bM@? zR;G`STc!H!qO!0=GC}|K5v^j=*QY~8$7}dH!BLWb?x@|{f8YhqQayVIh1epKl{#W_ z-D2biyUL|_O zIrjoZRM&h*T}UP8LTcl3=2_ki%hR_lNT)vZbui8mfk97F+-wJ(6k!PH-cP7tgRA}MR4eDC0GpkNJuWP4A&=+Bl zq%k#~iGLiKZ=Swf%4^UnuV!uqlc(ah9wQA#jmP3o~IRBImRe=`Y%X z0A97%HhZCO-rGFp_W5&t8YrY`+2YNBjQ5CoE>oKn=dqf53H4`c1iWn!+Y5>tFGstY z*axO{*Ot)ZFQ}7!*WWa)&bi{Yt`LRm_wVq(UfFKKd$qMHccyKA>><&K7i+58Q#Yz# zZ#p3i1F@K>M;eZo*Gw#sO?vXl18Pk_O_kiTOhQYPN0&;6HaheX^$qivn>XJ@A_BPk zxAg+5%Qg@#Q!Z3&JZxgpTmj>?Lh|Zwmz3IE8l&WbwnW?fo0-0kjzvuHKp|1~iu8Cy zTf38F?lO_#&eg^+`+*?h8K03W;-PySm zG2lFRF8KWKg05G5WGhfreyfB!XBwh?w=|zUrYq`Fqs%+FzCv^D@kTd}|+u*^|C7@-b7GO$y~fv1Vlq(-fOa9c?i(^WG7md6MD0 zRWDBNP#QF{j^JXm@b1D%pePGAozmN*ym6XZA0B?gdrqA{lrS>Mg(OWevqUyonZBdK z^KB?s&rr;AZ_cn(%qMa61_k7${$O9NLjqr8Ans~Et6M%BfAc2QCF_o~KCVrOx;!(U%L@W2~2da8^RZJ5=Ia3s<{V~?~aH0(&B!);4F z-6Fm4^GnlWBl}03fDZ)rR1H7Yo%O+Cm~QXUQ!aO0D!!24;4`41RX08U0wFZ*Smd^T zqA5Dn5-*CZy>QCBFFSrf$$ova9VVHJ2_3e+-{0%RM*dt5QO_2S$!go2ALTS$*=7ZU ziF0wCW@jD)KttOv5Rr;aS{D?PN)Kuo)mAEp*hrITdaP({@XocJkH_*e5p$-U1rNA_ z8g6d&zFx-E%ti*z3+A&u`e&4(Fs<*AcZ_yxHEiWG1P1N( zh0&{OJ>PvVjKU1uxB5NW{R!YJPT8!F2I7)l9dMXt(Ql4YQt?|x0BG8b!uVc z(O?YO)|%f0@m%);Z>#IB-HmDqqHN(s43Du<56$JfMJWVU_IR=i_UC4DIVy$ z8w(VgrQdR?N%MpJW+*Z6Q+T6tk zlgoO!ra#m#jmRe7Eu!n8(r;(Gq*uO)%4s$AxLP8c-2A}~ zkKd?sEI6R*vM{=_H~aH32y=}WS^P=RIgvrlZ`NxUy z!+m|}_-tl;9)ErHa)mq<+hyNozTX&W%Je8sJg4q9rX@O6Ayt`vd8*CNosgHoV3dfU z=_##L=!#PFW~OY6C64it=<8Ldofnj{~fdy7iW}B@R>YQ z0%4~QS0G#UwBI(3;^2{CHuUtufHs(B)zxyzI>`0Xy4;1)>gtMR!uMRMQt!UKr6~G( zT&Sti3YTn6^z0Ae zHZ>7JP_U|IXu1;QP7=c0-oW?>hw3>D3=X*u-4)NTSbjc!`FjYbp^?y|c*(k~y5?B1 zQJCX#G8Zo&n$~vxc#cue(ta6c-L7P_2u;Wzg>dMfcgH0nn-vR{x7-}@lbR{n?kus- zhIzt=uK~Af2G>t;PG-U_GC)7=H>LHDBze9Pa?Wzq&Sr9Ka$8ME2Xh&ROrH-jIAZ~N zCo)0k?&l8o9@lmghHT~vwh6`#qCm3Zr^ z)=bx%sb?la&;v?Qw?6EwtZ=Ib04S4LRwkN6U0sV^2SE} z`TkPWYx}nc4&Av8br>fLn^Z6T9YOkcReyz9`l1_hs8P!Hl?kpJoM|Em?oCzUZZdGEplBTm;A~xk2?^bcty7+9MITtv>6H-Qcq&)UW!&9K z_x3e8n+c}bTG?D?rzMV*u-Imn5dyh+B76-YoMM;6gETt|X@*`Q3wZ(vby7u?4O=Xm zq+@UdVZaV6)?dILlTCO;B@ihaz3BUl^yPbym(A8|2mo8UQ;;JnQI5fz5Bgg#HVBP^ z%6VTrU&c3~5m^P^32u7uO<=zZaQPFxhG``Ke#^U`y2_H?pBjwz%wH06=^R17t-fNF z&_iy8HmeWgsc5X$3p4lRhlbokE%nROn>a)Rj`ISOUD@#hY4R6KU{t`haCiB|V)SQx z9Vjg2VxPcW{;VaOIuJGO zq1?VQ@sq-|)}XxN>PtsNf0KLs%ibB14n3gaZ;kfjR7@~l7^&jY92@wqcnewNd=r-_ zx4R#j&l^c`c4rh*EVT^1;EXzzsvrAlY00XX7a&RY6<+v3asu!$$1r-<4b(O3uMEiTbg^3JgP|`Lz`Z!3 z0QbYrn86jfKW)}>@0|JVMw;uOqo19I!4nsQerJjPMT-k(;a#+b5J#SZ=`$L^H=I@p z7*Z?1h_NQzEP+P)lls~Q&<@`Zn)vG~lOdp=+X)_MMn5~eMaAD+>X^^J@cqI~v^2^O zD|rO+X!uJurjm6Uqizm8%1xgKV$!tx;j+CLX#w*w?)A+Q zXyMuY)gde=CkK6LCD&zkcUu9|cAzcu4t-SjrhbHJH*6mA+9LBF9Ex<=z7o!B{SHjI zb+sO|r!X>VwAZr1|B^(AwsIvtATb;OiSfE$VEol@KxBWR!uy=AF+|i;1jms?TcPhC zO-SdnObiZ<)rF2ueDuzX?<%pk4Cb{?a;dJ^gy=!miQE*CL*>iuDmI}Y3^cs>7w+># z4!lA-uFPbjD7|3S5p@!`q?;ENJW%oE9x$HLu*YSau=&`)?#dzfWzIdtm&~Y06C8YQY zQigCK7Y3gIBO!J&jc5c-)HRBUBj$EsO2UKDYX2uwQ!s-7pK)rExDvQL6Z4gVAFd^n zV3^aeT^tCM?A#&2f*>C)YicYO z!0Zc(7q@azFXw#p#?u-@wAs*Sk7oFG6ezx)>X(-z7;vfWqDljRbJw9S>ZljrTt?3q zCc6p30_$n{_07cwV~)uyv{Qe%tKVP(Wy$U*4QfeN z2n#s{wdBpkZD6#?jjVbq4U_!WfH0|g`aqO0!(ff7OvBW;c+yk3ZRr{sFjn4AGja%p z?0Mx;H0VwwnBl+d=8w^ZRbP5b!I_l~aZHyp+5~6v4B8k=il1_R0Uxq!6k#TL*at*R zo?1j7x)O1tIlcXiU?X^yT1e*hQTyFCpYnITsf~-hR+yjCW;m|S*@W8R0ywPS8%B?a z-hE3!dV~!IMNt&4_B)oc1Yx&(9=4m%tDkmyKih33y}vdX-CV3?tCI7Sj)Jfja&6N2 zEjy3(5ok2n(=T-b3ycGQ<&rC3| z?uQ)w@w1@d{lID}l&g?MnNsoDo-lk>pv7!YQ@lKu+0Nu7Dx~4 zM~{Qnqd-zDewQS&dPX?`>Uss{Nf{=pmln-7>_kUEysRVki;S&iJJ-c((|~v)Kt#p64)g1Lfs>CEKfRHm-x7z_7&S0}i4NxAq+-YKeL$UsR1KpB z%!-?f4d1BXR*Tv)ko)qAl&LyPr)C5u@#R0te{{ocLg6ew3^5r6t&%tXb2`1e8cBm- zfbnQ~5IV#f15{vOvO#9g(4mw?C66R^BB6uFdBX}y7#At{TNk$~g|@Yz)N4>qK~2Xy z+x*AfrfP5OAicOBBiwcg;ge=vbDM1$h8<}Zn?EaiemrGgD#OhA!B2H|P@ET-jPaY{ z2MANtQ$U$BE3bwo|1Qh^XYoi&di33Sy99LFRCN8cSxqKkY)a2P1H^=M2l)tl&Gz~x z&@Wd;oE***eHaW>jGbI0lcJc(9NG}Z^T?!N$dkFI&yA3Z_l5jMOVkr6dTTodu9ZkgTctk`8mCmC?t3b`X1eTb=Y5VYPnVa1!6;3Zhhm#%ip&6g~CahUXW*0ZS< z$#&0`V{ zW&J+9BPvd#^db3_1Azn(L$T7Wu)0w0eAIm;GB7Xv=i!4#UcCW)+Ih?5Lg{~VH~+w6 z$jH;`yCEHLHyJ%B!dlqXOqgg4o;}1gCFXr5r0VuVBPM*RcvG?n%~io+({GG&C7=vo zl&kJx99JS()u#cu;ag-qEn4-C-m+hRfDBM;c^CsTsnxc{P8tc!4p_oQYZ+M82nmQS z^D{l;)&5L6TN}$V$?`0T%DGbrKCgkyezDRr;H>JKxKtOvz9wH)*kyU_t)DFYsmiq< zmcMclf}SGQt4P)Mj>6-F8x?o@xMkXe)FiQy5Mp6X7vPazjjW~D|7FGPnsP_!eXJ@( zJYJH}wh~8U8Y)|=J-1y<)JzV&HuM&Wd7$rF=ANE4B^H210Q-Mc@bjXeMyEw;w%$Y-&Az4<;bAj==v*4)s-KJKbb z2C(y5TW`x>#qclTO*rUp1MjK#42T!lKp`Um)1OttA2Q)@|3~`(4DCx*Z-+T{zbu0# zG=tuIX@~xFoWI+>>j!4A+!&xtiVFL5)F*79^#%{_?ccubPanA6z@F`OhQ7Tm`h){% zP4F6s>@oG99{h)e&^8?fjU6x%Uog-BJ`v*b*nzzR*_4V(z$H3PzCEv`3EJgvyZv83 zOS^pJl_-Pnpw^T?vFgcPem#Uw@)a=AT&?TIJ+}Aneq+T9%=I~H6ZsRKUVAy(`d_~Y zFZghrgxjA;>^%dkzCQh|i%!jZG9kN(hI`W&lma0p-Og8Ozl*8A7%Th`pSq|q8iyd? zq{n2t$M^l}Tfg6dMgRO_S~6D)9Wk-OEFB}_hxt-%XgWxtN8se`76l2@N*=mHZ#QuW z$=jD>pKR1sBtXop#wbz!o|RrdR#dd=6n%`{&*2JQ-9P{2|2mle`{#W!R{_VB?`eI- z^iRfFyUL!#&vXW#40Bkw(205MVQ~{$Odoo2gvec`?!=ya!)Qb?0ET@+I{BPQXMxf+ zo7udK4KX=*K32Qx6ow|`!tZK8|4h=-pAHq*4pinF^^uW`Ke+Bflm1?vjy{>@6hHGI z@-=FgWJru%WudgcF?yTHYk8Wxiu%#d3|Zv|52V;k>UXfe(8Ps~{7*eQ?B~sU0r1#qfqw%Sxtm?W6 zZ0vMyAw4z{%+3CjfDgDHAvPNlp|UAdZWF!v6{Vf-bRW%rkeU^SFk?A#;#dp-snU&q z#Ia;q_Ym@xSS%a(zpj5fD!LzED`))Lor1At2#W)~|RRNSrN{mqI0aVf$lPj?3U(z&E|X{Hx-m(c}6?Lh622qQIF zCNijI*W6`LJxJc%G6_+C?d38JX2JxuQZp%L?|U87jd3jml-xA{cZzi?ye4y{^cJe@zVGP8E-pI{kL>Hv;y(e(Y_y@gy^GaQKAjni9;qq1z~j{47AK?F_LgWt4A(u> zZrr2uBQ8~@NHzpAsaJ51%Kxs`=8rSmRSio=+Ee;y`D}FWJAAc}Ni#a@hP*R>a`0EU z=XNL2{6vmY9YJwNExZZ zYMM+vHG1iXS&b~e_zF)@C-`eT0~ z{(shguD8g3-9Ih87)fA~T(h4;fe!RW*OZxzbFB4^UY$B?k8^Xns3F4+ZbmFlwWNh)(J&p|vbHD409 zHH}(e18pYkyE9RYPw60*uhZD^W7H|a*v&XV%0;AdZU=zH#%m+kHNViKsx+ojjT z$oDqz@8^Kgpgq?K>)5H|Ikflu12!MV3X#?MQwerKOWqgBe|L6&6427m4ne(&gIy|F zkT{DIRa$p+F(D)MrIx-C)m>gVr4Hu8=YjK*#QVANtxLp&Gx}dej9D}C2MEuNd!af& zfz*Gp+5S=VV`E4O!ngobf#|C;SeZ9e+ppRewLR@(dcVx8`tVi}s8p+BUG6 z;x?$pHvXL__db0Abs_9U1ctw!rF{jvU||1kfytkLGU^ztlKBvKu-LB`_rr1hU{N;P zste!A-5l6?$#G*zGf^%1uG!$z8h3)AJ!9fuX;)Y?5^}`UM}NuP@42uXRX_S#LY5vi z?S@zd@8r=}HM~d0Nsa9@4q|f(|LpYq>4O!P|TLzyHfD|Ex#BqIt&H-p)mRKXO(W?W6a{?k%9!k-bCvc(zE+ zGp(G_ zH76BX&39L^1Ux;6f@`CKWZQqA&_7zxZ7{dUD_h#$)eRi}Sw)MmY9Ef~%s zY)-Ch3vMr6m50$SX8+|r@D&lB%A5EP9UIA@7 z_9z%D5qoz}q6MDQdigqJUmcTW3g4+(4DmE)+;mn+M0btHe+NZ5<4RrR@+^n9P{~Z% z4SDeBeyGWV7MPm2k>}#xRaIe`XUCQu+IDSjK9PaaP1BRn zm(MXhp{5{7xomevntdOk0O@0JKKKX2MfOCB&&)36;6haTyVl_to!2`Au`>=dD~(SU zpxCwQptV6&PGE%9YmY%K;fh~|_@9>gH^vjD!wQ2VR)o8z?K9ylaK&nOsFvK34g5c& z&RJ`tn8O7(MsC~dOr1zn`WRAjbu?I0paS*G?d&gJ|0h-U>;GJDf#a)qY~tKr_QF-0 z9JqLg4@}1$&!sSUIH+;VBhe09GD-SCX*M7+GfU7h7xIM`q^0Wi~vXltWL2e!)(nGL| z;SkY0!Gv91KAZTkR5@LsNQMYe07U$2h<3Ig9HYK_@iE;#grgw# zEDopB+J+0cltJ(4yH-i5cV3fKEI}z`?&9X&(MCmKpVDx^b{;e7Sk0pnSp4E{(dtW( zZN+P{`FdfPsbw^(2>1JYa_WYx?H@{(I!TEpYg-?_+NePhV0B`A7;~VSMcD~zF6FYd zDL&|y(W~+^iEBpKCwAu=y{C4Iqco}Fl4OQS>KpXYh%2qvYdMe z6IFQxOq`o{LkNGrroY}~6Kv_O--Bn6_C?rB53$F$(Afp~5l`(Z;!jy{+9gZlk7G$@jHeS?q50@$|mZAcwJ%(X79Ys3|9IQ^N*bUFEN6ZB~cR) z#}topOh;XSdGn(yZ#E5(h%;B)8>4Mb8TZ(!E#&C8Xu}SaiZGDG)1K=sv|0C8P`?5g zx`wQ}hxe%Hu|s*YN@&SJ^4~Z10s>3Kii@^6hK_wGq-Vld74#&(dtPOO6kiQ`YFwB) zUNE{{wT4-*vF?|XIKeg$nNH)p^zbaF!Fz!(t%;9f?H9)|i)Qw7p@Uixlbt7BgN{(U zY?>>T*kxKxw@UzajjTmb!(}U%e`j;iVyWp~4FPvAaf_gl>|YhYzw@gPR#ToHVx8f` z6%wAnJ+U=fq%S#b<=F9#eixCYl=;{rMLAcLqjonfp^zT&o>{3`P1LIe@|@N4q8H&-GK<^@r6cBIR)~%K;mPso4X;|OUpgaXG$rti}@~mZRkHxUroCbka zRj(lt0xEzys&Se0K3#QOZc`Zja$4&7^_yVTUz&J3l(Qe+V>p0i)Mw|W={Bc45e3q# z-XwxnHEKI1G%ioaZWB?@b!Fd+upc{XKb05{C4roCGBY{AA{OvAv4#kNYyw&Yq&eI5 z0PYmL(m}4EYVOf%(_{R>*+T^jvcE=nhFw^2d+i50%>wXw)t_7s-#IMDafJ9gV-zYQ z(qSs`<_q?CwAKwkS;5bRt}4oRKUcbiX4f(~dU;=w99L}Y+H7G07Yqm%>*z6B+EZ7=&m=+*bQp`Oh`s)4 zgc;X=3MF7Rk{B@3+*<306o)jUA&vQLA|K6FR8MqfV|r^8L4$D=gmKniUY^Eck5;U# z?vFquM-)c+%&>p69IMTY7F0O;6961OfF``!lE|i*AyL0{GBN4ohM!!IXl5&$YO1hh)voltVJW;hUi&?cm8gM%om31Df z*hJqiJ}5-YFnox|0}nOLB%i_n7=rKSieu;NLx=;V(Cl<3hcCPCNBBl#jXRQ+6x`** z?nPY1jZx*P<>BS37=|}m0m}uMM~DKMmCoyhTL+k!^gw2t6;^HyHLsB1_JLF=n<5wB zvzn$nx&aYEe>vPrhMj*A3w7vFvsKGTt%q3YL&yX>DU~@Ds!{h}QbtQ76|rcNS;5(! z{6Hu|=&@gY0&p*zV|oO1Q^fTku43OaJp7!h3nh7Uu4V;|1jQ+#*7N-WXS{+NwT`h? zXv7(y%^>iZHNJD(pd-b=9eo@@c|+j8?JG#WscHhvW=%EZ%9I4%&rR~58R)>G9UDF> zUd?8IseD5?aeRKerG`QG(5XvzeS%odomoOXZ>m>ZZ8CU~cK(CVm#n$dVl+(~_45mg zZb+z?@^AWhuSdk=ulY*2TbQ0Z0uD<)#dAe9^#JB-@Z4GYdR8w?3+3udtt>QX zhZS5srsc+~9W($^eoe-b<$9;@uDds+cMIy9iG^ut4h^BTl$AqfSuR{aNgk&fJDl%h zBjG<7y)cWu=g%+H}ZK$|4Pii zn$&$zD`r#vmijYWnFo|GxOSqk*o2RAP6YLWSKLx77xsrmd(?*Wbwmu~(m2r)KoO)} z5s;csd#Xy0weqZVGPQx@OlGC_$ah~G1Rw-IY~3+bE|pF`W6;9*iZ>-Y?)a9K6CI(nPj z#Dnuo7N0k4FFxERgjpr8b}q|mQpUWkL6ycNsV$yRU`ZMygXG*E3pJhDEM4tqY7p8f z33vG=t*wf+gVkNOmOl*LHO|(pdk0vk&iZ>0+pHdsaFm2Hn#cK;LL3qA!>KdZP@!qHG!KV>;(N>kzZk&y6;8iM#aE+kb3>+0?FM)k17@)SUKU)n ziN>&f>>7GuUdqs&#p%ktF2eYp?ZRkvKqeru?1qo<^%+TBo@AshVvjCP3cH0gDV~Y* zP@8NFSAqKXZ*M6938->AIeapss*6)7X5yBAey@d?^cEUGxq-W&dvd^k=e4z39i}o+ zVj?%F0U0|z;It@V54e~+NOiB)BHMWrq${gZmUc`VGgM139Kyn8CNMJY>J;Y%hn}DQ zU{p1Hn+zK^h4N0Fx*~~yGTmiHu;O0cE+Yt|{BOhXz@ejz0D3W5Ure`N32IA{eSeBx z6r@!GAMrdS!U#DF5?XFQ1rfEyJ_JGc7^}(VlTvDjX_Ze(gwn_W=R!S!ub(9EmEr9o z>BDY-?8#J{N0M0LL5pW{HgzMU$2K5#w8v_LO)|qHT(;M3I>*KF?XhB$(yk+RL>^9SC2l{E5Um5zXKKrTsx0&8TA5jP2G2+&pwfzB1hzxN-yyhRpLpg zR?tYJ+;x_jzpN1Hh!}QSi3zKy$6CjkhW@#wmM2cqY93_lEmP!_um_hMzsV&=Epl z6IwkvO3#uSlWL<_VrPzZLi3#LHG(4>heoRW77>Go`maM(EX}!@zT$iUkNI}5{roYy zjhW9+hBeVUV^(q(DOQS?n#E?Fu%J|^RLIfcLpfuW9Iw@cCOM|!jv6tGU4d~AS6Ai} zD4Io?Xd6rurp+eD6q(OXN-&Gcmdg`r3$B)m*(0n7mS-xxH z6B#kk5{f5wo}T=71+;&5wuG4vxuhzw@kv~bycXLMb89{8=7hAReAOA=Rzu0PSI9f` zRtek}pl=}{RBj_xY>b;@9>8ck!_{WVEwgA=G}DDC;@YAuND0p7@wVn{kLTwac8G!t z<8FW)s(u0T9-uE-9Z}B9lP&j5pcbiIg>Rl{AVq||BT0^_hKm_%*~=(>I=XC?q*dC6 z*}j81nCq8)$Y{-B$x#;-mzw3cN)3sq9N9$GtNx~!JNDW`{JWSC&N~F96Yn6G7&L75 zHCE=UMc(}|d0t3Ox*@w3MvZkI;!!0@LqGLC6R1Ss>Wp6mt2VHFYu2i|w;qP6;U1`1n9> z6kB}kQt9aMek^)vEK_Bf{~+Tl$?_y*de8Lanxejvr=lddYwAyAaEVZK`P%6p#*xQ0 z9A`OsK(a1T-!aC@w#$)DGSEJ@ye(NlDy@9m0gI%}d-BY14V_s@?FV|Rcc4%H;Y@dK za;jobL_~ysc$pm-|D(S5s55KE>q0Mssa%y)2QKIpC>qLdJH18fpssw9`AYQFKY9WD zgvz@7N_59nEYgI8)Ya@hTNe{`5oRn+Oa#e0&q!m^m4_lMPU-RIF2C>3rXVjGz&vF0 z+kOgv;kW8zur!rCqdwj39+UJ3NCj4nJS*u*X?M?U_L?fEq2rYNvaMzrXo&HUZm~5N zX%kU(zph3R5!j}v70b(~s~fMT0fbf-5M(`{wAR=|xs2Zdq&0X-mJhCvQ6^hg;xyis zv;E8+>9*JcGsXTqr!g0iFt%@}mFO4=jiJDgSpt5fTH5CZW-iGU4tjOrMR zgGhIvp7u;ux#nzbr*Zxew&3>P9bNb|kwKa<_4(7A5il-u&|v~AGZ zg>4fZ?NT~q@6w}PgbZWa&kiL&9X)Ox(&tiC+S5K8TH6wHoSHFOn4jzU{HCUoEfh;~ekYg4b*%(g?~PaZzK8z9@&5 z9^!Pm;j--%%x`bO*oT|8TZ|U<;@H~35?Mm(qMr4gu3{qg%Sq|pKaiL1#4t%r(#kVG zd+{vcMd|q$YMF=J5*YB@XhrW4A1&6b#Cvs=l#u~VH!_073$HH*Kj0EvpDk><{+yL)yE;gRn1WC!ytNVyqfE zgLcSrZ~B0TR8$5e|M8G0k8MkrB6J@?*wz0&cHts?=!CPqzE-ojepD-DQ0r#FtFXh^ z?+JGwBl$KM?P7k6VuM0_A6YXJ4p+BxTubSs6(Sn$`g;!CJ7(!lcVzI-Q=+xv$i4n{ z|9(e_=cN@tdj#8`=Kr5BTvUWOpxe#KeSo?^hK(scl%43*)KiCgp+BgU>1aa)@eb9P8vB3#bQSX1>@2^jN z^5N;l_R!Kjbdv=Hg*-NK2AB5pVul0oUHngXM)pz}&G%sc8>&oR`zg1>Rue;(V(zo* zulvFVx38pF{jPz|U*(iN13XQX*+sfXXGe$%ardJkg=zb+iEj+)$lC7ynnhv7%4)2H zP#wCD?|;DNRop%^|5`DWma;4D7XWOJeL6j+i)e4fcb^T?)$UUiRLN+z){5YgaYzqNM)aMuksD z{Nd@6ce+A*5h6MwkO)ZrQ@K*xY?wAA4V^tmL@+35pyz^bng~xv53AccWF< zhUv^o8~Z7rIN(}>eOjS;26vALp=i~o=Rf4dFLG^G1Ntq}xaqZv8K+IfN{zPBVa@$r z?=Fsmp?0^YwlJ*{Y~PPwtbBimrGS+hq9MC!i(|B!@L~(fzq06Weh0)p(C;eK_n*6h zJqCMUIYp}HnD@mCw@=dAojK~EwD;o|#bEnc+LPq_;@$-;v#USIrr9GxC~6QfIlM1| zyl)F+G>JIMgTOxSnuEPB`M}ri`@3ESII53P?0cmquG(1k4Pf5dANQ)m)3r?cD|@+; zXR!P4#{X%s?HPFuN)?Dmnz68DsadB$(9<*$rI40v=c5)$2CAZcdUe$~5J zjeQ-~cPz8p)7K&P*q0q%Tu87F;R=fD{|o2;FP#6GK7Ib53TK7{03^DeS2EdG@s9A# zQwa}KMU^AHYL3q+6_${&D9gSgxpHc={+Qkw}9FoO*}SZ_~&i> zm32q_K=wJg>E-V|9P?55CINNakKDna{mF0JL$ds};gl-BxD?BGg^!*=gzBoKs-1-+r8!C}C{EurV;uZx2e$2`7+fbLR&2 zz7FhrB3xG3t4zT?J!OtH1rK{m?C+-Nk2JHwbR)e;dXh9in;f6@uHQSW@8Yl@U0w)# z??Z*TS`pt*h7J{kP#zg3-2wSd{2|oycg<&a?ZQiNtk)~F_5}tx7UKch4{S2?j}}-Y znea`}EQ-=;7svON>Kh`xUpyF1X`n>YXJx}gwlQ6748d4AyL3Ul-4u(@IILwcER1S@ zO3v+QGo#%^B&IX-$(A%73htl`{9tHCOo+WW6JY+6bsU&TlKWocNPvIe7IH_QoPM zJy?2c(7Auu6DTuK8KeCMXpWq|%oki#@rn6Niy1WxvgG@TIL99sR{`h#u~Bu|+4RS% z$0w-eXj^OFpKz)`7m}Jw$wGqTXc&03@_2#FN?UqLYvRzb=TeQJ$GSz;+M&ZVj{%xw zb^7kAQ9js$B}{A^g<$yPBY%|vKmf0b%%1X@2S==>mdW~0e&Or8R$ygY(urfo7^vDX z;eZ9Y{up$E{%Au#Q##;4xsQpKt{{%En`mMXH7k1se(^n^3?~`McLeHmtIp! zBTkzECemO=A>H3A)RK}A!uDr@$QwM5sZcb#G*y_0sa(!NuiCQ6!X*5=uTmsM_ zs(OS|{c~Df@aZ83wjg>4@;d zBFjbYYi3gUR3sA^nMl=uVU13S1rTbz@)N$2{a3}lzq?sa>o=pmDx?nB`^;uY#v&vQc2lJp57e~ zmV1}riV2`gz3+e04ob?Ht~IVd>6xH=&xruvqHB{guD_|;n+LIOe->;HpebQgWl+#P zPRXgT?gf*<34%AJl$>2GDgyw!`#Sr(ME)vxsZ~!-UEXaNx!c(RmkXHsur!)>s**^0 z>28Yd1M5n3s$%53S~eiGeH8$Sg5B+BHr1uyr$tfLz=-V{RR==mbd4&YMHlj7kYEs% z{BvW!dlL|$`>s?jFe1LjflwV*b^Y?`KdLDv)HrPYkW{codQ9l)1As;bKyX#sB1+wW z^wWb%psqBZY<-ie*U)_WZ1?GxKxD%&BsrmsW=MD&1{AUSY&R|lj|h8hJ5Yfn*KPvc zq#J;de5&_@_BMf$j_2b=A8(o!;07Jv^AWCCf;Id@*hTQ(PNvDD?^*}4N62CqBm6H4>wBFr3+9l{F4x88R z^u`NEO?|T*#r77&v-2sXW+7LAP>Yj6!$;PK7#F;-3vAS%`B5AKs1LoumsrAvL$1hA z08x!HtfW_Vz;219!y;882@H-~WrH`zGt(2!%3YZ5?R@7iNjndqFmq<6ZrvTDJo(jE zN9T|LrpnCx4J+&7ri})!EMd1^OzaZ#%Ys~3=}ao7wmO0G-$gOIIK6W#8Fgr&?W6)G ziKp)nyuT2snn6Vac2zsYreKie1fWq(08w^zili!B?nY(uTYcX5VwScUuCB1C$AF2{ zZqT(fk;fhY-GFzO0IC%m)g!*A1Z5sAY$qexJ_E52h55)4qazAWW!|3We6P79P(@7b zZgdp5zZ??#Cpp2PBV7=V+kQyEkr_i~qbp90eS16lF0jA9cjHq_1K7VF`X0l&ogJkh zP`}mez;4zZWB-{NX<(HOjepC?MI*nvTPI)TyW>a=X$K=XXDTvQDNz<;))HmJOjP@6 zU%e8*dZ{lrKl!4}{&b@Ea9h`c6m;%7z;YB=Y}}(`K>#ocEShFXxOxV;yVsGF_m$M~ zasr?djd556aL3{92NQ61-JO-9X1-#k^CBUc8vEZCfB-@$kV@*;^u?Z@>qwUO(@21C z>PUbE_L~L+m?9>|9v~X`RvL&>UHnl7NRpcB?P4or;okw7f`diC7iU=;jFSXwbOAoAI9bFy)jYxd(eCDgwK*%0 z0$T-=PE;_(MEUr~;+|b$o6W_lCH$3$A=v1M5s1LHY6VKsf_6-#jBpx}?R4eCw$yQc zd@nnKL#+&F6eF@e5u^F4`*hMN_PGM8Hcp`)FPQhpyIxXyFM7Qgo!9~xV$08vvAt_h zWj`-4|94bP2{_CJkYI<8(U%Z2#sNr`DQC%$owY~@@b8{~eO#cA@zY)C(2)09YZbE{ zY0n)w#;}1O^rnzSwPzx-KLwnDls?Io&P;xQb8!dCi1S$R{off79rOVFalvG5sufj~ zo)E05wH}MNPL;MDHM#CKqnJA7BCbCZ0O?KXA$gAf_^|oU3D&f!jUcExfO<9x{F(eg z*TbZLXc!=O?_5?<3LlLiztn@-MF5GfzIX2Xm6r@UUngpccZ(W*JEGU4g5>T^lm9Cb zhPQ;_$;W}dyPn+F*ZmJ35ekg_ge|+i=jCf`FV>Rm zaL@`Su5%W#0KF$}SS+bdCSJ_EEsl0nC0E<6}1tzF$q=KyqQcVO6O9n!Sg_-P)FQ)=cMO=-K7#rG*>CZ=NWEqJeWz^ zg=n_94YXj6VH`;Ec0^H-&xb0;1Gk9eDrRW8v+W!D7t^|?TaS;knQ6V-__G{G<0z;+ zW{?xcbj5K@Fm8337RzM;-9WW=Y`#Z26QyJ~9`!<1Mgwd$S*ZoeG5{{$S_VpHYs?Bt zTSS~H5cRQ?S^`>}B^X+gPdP}=n&I+dQkjXUbo4mU7yeIyMA02#MI zX0|qNzSRcCs#Y46Ai|sBbLCp>-Ri}L-Q>ZIe7>c(U;wZOz5=RLowV2}kj}fGNHc6K z!fN3D&+9|56?q1k>r`AKm?A#`=q_Jn7sJ9BmH_QYZ_+}U==D@A*a?0AR10EZr4 zK4JvUfhoXER1yQzMiap&;N7Wv<@zF6p#nQt+nvi}F2Ez~z8@7T2H=wIi{{(QqfUzz z(=?=(CxC1HmPV>nj?N=budI#!(8B$UycfPmm8&xBB3>Cik2Wq@XB(nxS<~V=jCLWa zpqJ^|DsKEoWpCg)P;wew&0?*@y248>I`0d6Md4Z**bu9YTskxi#gerkn>d2G>N?wX z<2Y?V8F1hf8+7nnpYIo{e!8rW38LbH;fwdJPo3utyl_@rTO#PhLN?Hihvfnq{T$f= za)+`WBC4H>D54hMB$UKmxpj^ zf{ZYB9yMSGTREd}`3gv1QP@m2>2)3|7NAuG_g(U#p%m|tZ-0$D8y9)b1IP|g##l16cG+m>Rwqg(B6BM z2;V&8ef%Y>uiNH)zukt7T$;!7GF4oYDt)*HvQFn$-5JmNWyQ*j4S<(t#WdSRA+z^G zra8$CRH?1blTrBNY`Qc6o4G{o0g%r+{Hu}io6~qY{VpDOLU#Q0s0BdUw)GNfk0bY= zWWp0o_%4ytSn^CA2HZPZd=(RCJJpgzbGx@dW!MBN9Q#BCmZ$w-FFghLXJ$H%fB{hQ zPxP4thXX~fK>BOaK#J|w^RI!B1&}XBQbmwe(BK4h6&PWbr#5$}BESGP3>2yEWNPN> z7N`LAamqf)z8|3O=T`tW1R`8Loh3rUwLqFQiw1+`{&m1Y^w3ep;}hA`#^~^tx{V>WQC5aCEc@$O(_Yeq1!~8;Q|G zbaMyheNNDniUUe{GqU>Fj`uW+!ml%wF$Xwbs>VHRaqyO;dSP~DM)MNL5F~(3Ewl^e za-0p244#1-j$>`Qy{uud#PWqDFvSqjt%Bv|@<{**K1$nT8;$RvRd%#}9HhhwTnTPp zW;VLgxta5;i4;#Am?)}%Ry#2iUP{#6+ju; z6x8LT56`q$L5ZBY(e3uLr=`2cd$K+O_2?{CJG|Wf@;Xqjz4YeLP|<@U42ghMGCNR~ zPZV@>!T8z_SL>`_s!T@tF;$;{vs&CxvpvEfbAj{BPX*AR-3e^Z`?DVFm4jc2RNch9 z;ZvGCS7Mw@X>Vtqm}GVPJ43$rZXty1QpZ;KIW&RaazRq}jPW@|7sIhKh>^Cv*L z@mx~DZnjA+1!~HHg}H>F_S{Sd%N>DA_4TR*QZmz~i#v!DLpij;RCw44M$SMQ_94XJ zQ(bZaV3tuqj$%A+^PMTkaw{L*io(aAuGR^9-^X=AOJxAO^bFiIogw#lCYe}KemaeS z4)7jy_@P_40@`aE%mbD~2Gc}`uF*7&%OVeS&wnt zes*q?Xt-SztSj@JZr!8mWLV`tz%)nqa1y8wLNi~aKRR-qMa+(uDznFWp9Gv2IyFpz zZ1%kyN^nH4j``aFtx{uC%|p*2i2(BXmKu~UD0ut{cl$4&J;uj7BSt_2_HR}>2c{OK ze;ydjUps`14&eimow)%S%GoyoPU}0(aR4W_L@u^2(nAM8_Vbqho_?i^W#__BM_d2G zwH_QbL#8?b^rnN3((_zh5h}GdffYp~)uRJZ4CiKoqIHuULG$5xsg*`1=y7#JqX3R= z2Mj0#DEWsJ{v$a2U;bS=@zn)*qAqmgyImkyD%iyvVs0z2Jsg$}Vv=r&ttn>ua1MoRZ|t`#~_c&xJ12Y36woJqE4J@A$~|eYzuXl+q=y8^?CitqW0mQ zRG|BG2lr&^@6yDz4e6>NfP`#Dd|#!3^p-J{OuCmH9FY5 zMpYdDYVFjWzxlHc1E_e-BcofU?uSG;Tn*B(ri6fvB7Lz>JbR=iw9}BXYad@ww7_uR zr^9Fa;d#4VR&daKE*YRgmKDNDY+maZ8Q1r2V95~zSK6-yi!0$-ox{{~v}Li-7mmpR zIuITmCowTgb~&;QN}BYoxIhLa5x>#^O}-Ur$6344n4Z8&jDR zt|8eyMkr?2-MN|kkW298Or_{el+0R+9_y9qIOuZ}QxT)IOT1;rYE!dh^C6O$Q*qZ= zVdRN-i^4w7Y)t|P=bznn?wKofYUpr;=`;fU1S3EDkJ@(3%Lg;H|No{F$1UnU|MoQf z*P1_Iz6lWDbd?aNd&s|x1^~(SoBD&jms93N@P>~s_xsL}oz*A#`vjO7k4m_e;}XIr z%Tc#;o6?l^CUE{ilenXbS9737?RJq*F}u)tkJ;sG#lQiJQn|tMYGq7rzMvl@Q%cAe zV;6pV1^E0;1<>8qf28sYKnFQ;QV|qT+cg8~8K=s6tb3c1u2f}p&lXkFeq)*#F+vKd zhM{ux-c(R`pP=2huP+gnjBPB^Bacon=v~eUNjg!}9t4KGuJ$@d8ODbXvHm81rN*HN zD!?SKukV)*kJ(3sql>AIjIgNTOFdhkP4Jg*wZ@8mBDQqY z;7hKKgUxvr)x)*s4Y{6=-l*N%9C)sGyWswglaoa#dGh^>;K*r1ggj!~v36)GhNmqu zMkMQ@O+G0>W=qPQg3&3m+2O8&1DUi1kMsnWxcOq&jhAqU{alIbD{{bxI_dZhvSn3P zv-=t1Ky)%YHNf~HD;ulX5oaK{QWf*WtGU5eQwdE`p6ubJMA5!!xLvt!Q^b&rb{Zq_ z{rz)wjb_rzz?=_j7-2wJjYZ2(l?$D3njQG+*;#~02 zQ;|RQgv^?{OnF{mekgBVQqNMqrzf1WDQ~^jh8R$CLv?JPVd0#|7PuN%vCp|RZ?ey0mBoXX-L*r!2`CKYrh>EsP%!N&v_J2+s?tDi<-~Mf09BH z%#o1ZQ;t2R@sml1Sq7}XTq)jn9kfl~5*RJJ;%8Tc-4DLF1n14Kmc_JL4eTDDb(ngx zZ|rW=#3Hyh&VO~Pf@|TUL{mV=x_imUsOuWyGm=vUmaQOd1-Q$z&pD;HV&lE#gPT+B z;^9|&-KQ$FUPYXE^uua@1+l#{y*d^qW|C`lKQi(O*`w5i4|f!_UFRxa7{C>Wg?t{{ zmMZ=hT?SWZXf4|6DVv05~)M6CXfXywoRkJa*?EYVZhy-2OU``(i52 z*E*k!%PcPA73(=x`gbA$WGQqwa25-4LuPujbyBiy2(|K>dAj3fM}vVS?!Xe_I(FDi zOuN=R{ArPD>l`e@B)4T6Z^|5h4O}-#yaubt6Za5tSKi|$k|0-Fu&NRUoA~0Q0p2+i z6<;JFHVet%rophpDkCt1Wx!90x?ONF<8%=>&yC4QuBP4&vQazH)$2{`FPZ2Zd$V6O ztMd+CU#q3u5FpqScDoj`g62K=mEkXXa|x$Mi@nEb(#DJ&`v=Ms-1a)7X&5NG)}ezU z#$Ml{IAUf#I<;Aors2z$4k5Pkp}PCJ%-}l@ndTU^3H!9?({0`qXmRQmRO{)2u87~X z((faeKNVGBRM8d3buepxdi)%qTp3&Y%i&N_BZRArC@i;29#rf~@efX$DP8G046yNd zx>PF<(Q+!t{L(i$_K{jXOQ|A76V|&G>sB3>9hM6`{az<)5~}Le3D~4)6g2{eocR>K z1{~l6Iv>T1ra-DTV}htx?%)fS$K5Z#h~^fF*(|qGrz`!_|8uRy%U1TBaca}~#B_PV z_kx_$S?NIwUpF$%$CDnHWXprY?#MG+uld2iut>zgttRt`P7U6m4&h?lH$$3iPvx1f zUJmI{M37!Q8d@uWq=~vRpj%a{*lSuk`uJwVe(>_x^*Y`zCYcVtdCR$8@jWj~UU;jj zqKeg6$2_C{G=EqI?rDCsbuDt3t0r&ZD%5JpmN_3NCoNuv8LB;8p?$F-AU#+{L@N9? zX-eXtVo!c*MLPe&o=Et7J170#Ki?=Xh+kZf-qz_gn8;q&zFo`_t#_+et$B@^H^PyT zv%g39FEO`&=m6L8Nm(@9Yiu@hqFI8_Zz<Q>YznRYgEM9-j4> z^zVe-K)hW4)@I&xrj@>sIQbp$#MO1peuoUXd*wjKiBB;7VEcqf{_QW}Hk0=aq%pTu zl@qKI7Y))%XjujuR2mqitCxJZCZ=~z*~%dv-YZjucaI`SgQA0NtA0p!ul49^VQ6K1 zBJk%j3~z^ht`D9d!ryc`M$_ncky#Ep-GUQnyjB7F)wXMh$p78%f$v7&nmxd zJST+!I4|!j<~ZyDSmY;F@5dOaUz^+>U*}(L{nGwcnL>YHas*~nylgd0ix9CTyVosi z3o-@93sQ|Ls-EKzchXSse2L-1PTTb0Q|HN?CQF_z)Svr5K@R-f|CkPZeYz$JjM=xG(}zxg3KSA{zfDUGGZ0tp~HRZ9*yMNaEE*&w(6H9j0mHE7YBh&Xi3ckz-)#G~EuV@_#N(k}$ zd+De;xR(yq6vQ3C>JQ*T=lUz5+3Sl^!sT}*ALP^bRKXkQR}Q~LTxiLiNAB%`w8<=L z64~O=jNi<8{$!WXB@dvQW1_{u`KsQAY3Q}&c;GleEq4vX80dRz3a6PwFEF7_n+J9clR<92({$S9*K`nqA;PTRus zyqaC({<3E^BRe6V#!dTIH8yuLxmbC)N~{@qv2Sq%FV(d6D9h3I9 zv|AXWUP71Nbz3h67^;BrBC;YlkHX)Vg>zqi&GL$Y(Pm@d2U_$A+9$|H47GX*4tuV%qpBM+&S)~pCjRkItU#XNjyHcMvZOHINf>2fj zL@>r`7&(uQipS4_gv=pc(`w#%T;z<#VG(^-P-GUFEqL?~sLRiLwOQVS%6LajlUc+< z^0W*rwxZ+Nqcx-lE1|Kx`wI*^^FbA>;mneQ|0YCND--v=3GYl4_rnr2y)Ji@nVr=hH`!}FcQAzB+~VN9&4w?Y@s=Fgu6l_t&NZyKAIIuuQH@!h77GZZ&TA#Hp6krwD95cdr z$`l0T@NWS2U~=Pqs3@ILCAt41h1`+#`O@$Jd`ocOW@jwhexlJl{m7ayEq)@2{A!_c zV-*v;c1>w7#K5dh4yRLIX-bS}o#@~s1!=zCYole9A+AZ-X^<{}7FN#%sP?!SQtZ>} zk5qRo=NWltVuj_T5^joLn|EAEySubzGl#d8UP^nPjP_oT8N2_svRZ4a`75FZZ>Qml z^f|)#`{s=eh?0f2|EfFR{dV-^i)8_xYH(%q#Y@Irec0+yo<}wf_=i<;4zXj6H520* zE9^Hqb`(Q{1nd23HN%rFLT+E5t?+~Am++T4F5K9rdEXwjGO_%i8+NzZctzxoH&r zF$STWk=Bl35 z10xlhQF{YN&Xj^J3m`j{ZHuN)n+xjTg5YHy&ggvuHqX_g@$dV;;pDZxju|QOo&SBr z^Z`5cweP=?;xj+BA7|a07wY3W#K`yzgAlP+57#Aim-L)wkSuWQhT?JuIKZW9%yW5B zI9c3wvN=2)q(hNla@}mg`7><+bZaJCuy`;E0AP;WtKWtAn;FtRClTnaK?BZhU&jfX zD{oB0040Cm+|JNAUfM-i4bT2+wvm-)HCF4ioqVh*qmZGVmTeBDrv$}J8+a&BMg5~! zZaMiQs0|oFuNsuk3Uuh^u7FhC_o41i!FWH{vGx>YX+g^(P{ONrp6_pZH~C%%LjzT2 zsyF*lquaePs6=NgOWG6Ofei=WJFbTOAiJ`ilG^i3Iknvuvydf{wREFwbI~kairF$(H3gc<|4HwRmjVtQLbDs%$%Mz7TN=jhE?G zf5vN_b!)ek9i@kCTXe>V>>H>3zGZcv+Oks9H&Z!~tmM!*a?)v8p!0`SDT4e+ir4WX zR0-skW{CKnd*i2 zQ6!u#v~Ox+S!Rb>a@0@r6@kLO=53uQEOtLk?MZuDM5!m z%JL`e(bsolKuM*vcIxNoFCtka*!tbo27bsPYo60w z+af68vR?(j6^dsscX+%QTAs|r znl6^f9a$TEQ26Cx>a5YR<_cET@U!(nRsGVxOQNaxc(t2UxOr1^+mnO!nV_!E-skpx zglp85aIHMuYuTFl;bWYyw2M77GS!mxH>F-G|Iu=kgE#sc;UjUNl;zV+CBy0B{8IjG zj1)%&h*w;GO?xd>r)6+y2O}&X-EZ z<}ie`(NRB#W0J~Q8N4z2`p>{3NYHw6KK^6w*KPG3P&5VDWKe$w`BtYovYgcNG5OWS z5~g;sT2rSU{5C*l3TfcdSq`v@qnfEnw_=^KZ z>|+R6fJ{$Y@jr-s;8*@k0LNlpqVQh^@CoX0_4K0yzR7QYwU5_1@ao|0d8z`@-K1q| zmFR_w6Z#WZmZT)=t1Yy`)(#HfV@v88fxC-~|JhRx0N>h%qwplP@drl2)Wdx9$$lg+<2yk(W%;UFx@1iwq6@^{t`QwMO`h%l_H7rVd&(@ALlB z@ZsSSV)ya9!171c^DS_Adjh1;Qvp`g(wmQ}srEJRH6lVE)D`ok=9Aqrk3Z7>-;TzA z@YEhN`S`L)4;tNn01DCfO^~mTpRsHQRSGl;q2tK8UINY$dlfGJ;9fDjW#)U&M1lVC zszLGMemHLU6NB9DV4mB+Z5(jdU@98EdCYom8SCZ#YRnlHL~UeE0lDRu#A*n%e>Ggt zsYM=^4r{IBM+?FX*SAzJI7qwR9fNmhPmZAw&(9I(#IZ`4!} z4F}^H5y$xHXR2sQp;DTPr((n&N*xt5l8j>U(C32^=R*|~{;@m#IN={TicPpwz(+>7 z^u||{$v)KW(6Zulb2@U_mLb})0dIrA!eys;uCGi_kl3dNY!w)Yks)$!9qrnOmns!{ z?fY(eYGz(1+s~d^k8L6B>?*KarI>Gqm$y4L&IoBSb2Es(o5p`HwlzzS$RG_86a;tI zN&GjlD~Ns7UYX?DLW4+ji{W(!>D7{&BQ>6oTOwInw{J%Jt^K!S9{2+6n7G&fDgfS9 zIdT%f+UgV%KY>a0+0X}vfnQR@C&|*Sh+YMe$VYT@G=@qGcmxTa`TjB~M5fv# z*zT5j{IIMBgUD>d#%2|JV~N;sDQOnb^RUZ}u=|8yj+h?-{X1auxO8%OZolC}rOfQo zvA5Fgpkm=n`5|kAX+fZCDh)X|h&`L;cRt+JJt@64X1%(SlmGS22?E_km(Vb74Z+*( z*V2#W9*Xs3cN?_pEvg@NN;t7No%SJC;2EgIjK!3@NdsF`LcNEliX*H+EBovlZ0LrR zpRuQC&v1qtubNhb%k|8@W!L0EXt7}EOdw)^?^HNtXypKP7wm8)A^ zXJ?S28y@EpT0}HslBQ)ZNBF>Paf&uQ3Cl$fWYDP;hkj7&4nQD`ZZ@F!&D78QGCz=E z@CEjXh$z|}TiHh@etsC_T}EbL8RTk^FXto%HR>liaIyfqInIg>}pyl&_WwA zdBLhQ!#G#;?o~^REOyRHGI>kRY0Va6Q|1{qG^AZ zEghs=d-CgzwV=kh%L=ew<&BZiU^y~3qta>hfjhPz!;0I*uSlhbXG2c{ecvhrT@i_6 zH)Yqr$$H7oF49qkGo`(p{^nbj24~x`e$nC=PrKoZOV=*Kcgg9P_2&HQ8`PdQL+L;` zGahHTU0%Gq$8I3EC#|#fW|1o!H_0mB(3sU@om!Il+A}iqO*WIG<^Nh~>g@vVP=6}B zbhLIqPKNsbUA9x_(tvOC_s%Bq(KH{$+_Rf4&iO|UegB-M+sQ!8lt6sZ+V+&Rk_ zbHVf*BmSfGn1BQtJL|X+IrE`-cMRCXeW`aQ7{dHqDhL<~idU%)Ly3p(DpzFPeS676 zn0!Qh%$K_Ww%}1g&MVwpkGb5fomXDsd{3q)V|r4{Q#zB}>9l&H;Q@p{JG${C+Yh|G zAm*{ydIc6?ruYhqf3<$GnG-$z@0zTs{D0QOrScdV zE2)3}<9}1HP)fSdE*5YA3Xg~zfpMX&?ssob>Ws>(*WD9fS`7}$kTawjE zKX-Jc^4OqB^AO0>NWSo7Z!w_zYn%3WhsujH+%WIT#R#-3-A2wKMT(orQHIjzDHp@^ z9({oKX)<-n2E=4teHgTm<)&S!ev669d3!PkYoZmUTh_K- zh+i+Xty0fMrL#)v1sg7XLQ{4c7Da7XWg|XJN#^U9{-DP|I%z}op!wX-mQJ|t%aN<^ za?0*}S(wT=k8GYzM-^j%9h}&--qk^PMEi!eR*t^y()3v~QcO?w(|!uKmg#xv_ge`A zW-YM!!7C4g&V@fu)BPX{m$@yNAKn^U_P9op^gx{(%C#Eo9=~7VQUR}7grvl%XPgGN zh)Rudjp!g^Xxwlrq35I&fC>sWlvUA*MDmm&_2NdKwObNVwy;`?M<+4Q=hYBOw?`($ zV2w83T}W7*+};aW(t+Czhzwdnof$SOQ9%%%V%(FfZTFU9O`Emwp6QkDooHDLeiLZ?EUqrHe!n;&6K@K`^zLStWQ2I+p0Cl5bF~ z843oLK9Uli-ErHEOnDR{WlblaZA zndHb0t#Gcv<=aK75^tr%f33}*gBqI10t+z!T10Ysn(sr!7Gm1hndwtoyN;wz0;5%K;-U35E6sd{vUpj} zv8}w#(D-)xMd;3)wa`RpyBX2UssG{h<8e4~z>?yspVLm6OHV9a-%_$$6DN>#;wS9ZI3V8yz*F**OMpj5hxo^he92bE}8!|1R&;5t4h z)iuc4<`*n`Z4I$qZ+AI+ESXRoQ1L@<{gr@q$;Gxix)!#ZgYJTpJ+o$Rb;@;>lF5c+ zfLf=EXU9nz?~~0Q53;v(lo#p(RMBMHfakHGjpkw8u$SsE#UX;O@yMx`?~7?C#~m9k z-)K-c!8Ryr5hlY40oZFkCp2>IEt#Zxe?2 z!UHyl5A@F6;omcb`gxR2&NjZ7ER&0Pn3HZ4<17_t98fhRW?U=lKG&al&~)8#9fZ}; zoix*KY;j&E?Ol#S$2xoOr{d;Me>oE$#ns9nr!5H;7a3Dr;!1Sa zsf{Ary7i3g42xtxNo2`8kzj6aoR_)1^DRtlB40W7nkKG;;GV`k4Mwz|E$yqVBcbTI zFC&W9@n@D~rjHpdvLRxn_xg%gQ`}iAVMfzJlYwT)^7Pf7xTT4Q&N;EIYO@IJNYA}v zi`GLyo|yT`?~3wABwr77V?;1)?6ZZ2X-h$RincIEZ1ujeJQrh6B!|g5rU;utJnmt-rhnn^>e_(-n1_&h6i^$DpM%rXF5e(9;qvgCh zo`zm(V-VY_JgKEeM`^Qn?#>&pO{FZ4)Y$+0XZRUrvNE{e8C~3vg7u)EPV@{=!A}{y zxOBfq!0M_lhypt|i12IaiMPnkJ?+cXv7&GsaX4tmsfLYpqgXvG$u7rw9MyyCS_TNe zWWM-mQUhLem>4re8e}zru@%o@>BjYnA8E{*$r5Hrp4-mJh+$b!KrIj_Q&eliGC7Yd z=rQx?s_U}%C`rccpxd#dCW_rlLvda(hb`xA?LlXwoR7Kdq0uXy0yAUN<8BI zK9y&dWVe>4JTd63(z-nSDaZ5v7P0MGF|LwoIgrsH?xBsQZAd5o63hIL>i%Rf=mUIn z&Xss^(Cs;Q+96pUe%-B{=u68gQm6U3%RExw0VOOmKN85Z(dsJKbS*R?C<@F*n%*}2 zeA~dz+Op}#U8iJ!U;f@D`mVH|qsR}HhP^RQy`oDaF1Du&A0NGy&hzfIZsvwtO-1onk*AI^ zaLKOR518Dql!Rc^CoA$uruQ89xeRn2od6ulHgb1YlK-4^_elkef?UY##`FBxJoHnm z815$sPtP9;f(xyXQDwRk`1)+*{#c+TUC`k0lH@I`-KH$Kz?zWzZ1`++9xU?2X4pVV z4utF3^yvj%Qz^HozfR@;OiLaHS8%} zf>Ncs%fRL!AFw~V4bBM&xz04k6$E=OVZII9WLiU_FU&T4`OWpV(sBMlVV4;M z;Z5YMGZ}91LtV+hhC9a!kdQ>wHmXl(nD?#+^W-gc-oTJzPfhvf2UDcb4VyC^#t~!XG#zY{E_&$k2yzyE)5(zy-KqT)+aA_- zmp##QMP$dVS8G3q7K?*csbA{OXS^fVTiO{e8f}HSraaRDrZ2kLcZ-+3Q-@n zD$S;4gT>$4NH=Dwf_;Nixbvc3s(0xenO5t|gB2x1lTo=TM`UCMp-O^0pJX(-%pO*5 z(xpJBo?yqFVYMblA-d17i+s1b9m8t1bj;hmXz|35LJlq!O;KR?R;d+D_Ok8VC)626 zTK<<-me2pzS>o`g4os>qEX8Eq(QSR8Cmxl~q^Qp%4H;f9@SEUx5pFLgloPLMN&4=! zL*%BLbudG+7V-R5Wc|1oJ>mL7c_uZp>i&J?Hcb)OhOenwaJ2f!Gj*7GAX0XCqiAhSY z=bwt~%Zidz&Hl$i?fJl>Sw{ant!p;X%FvY_&40YhvYuTg08i>JAY1?QVhMu2A>@`p z>Kqv!or0$J2y7@KYPLl5EB_hv1E?8Z@pCeUko4+83OP9SOwVCeiMk`+14}3Or@r$5 z5IVhehNj(3SZSA9k%3t5chLs*DJQ1>_1Xnj=dHk|mjE~wZ$2P;`>SKh?iYEzcGCVd z$4pjp>Df%gPND`jOMP)e5VrTAsxrWvPc+#Q*R6(pqP#9)LGf4;5ll8=ozpcu)|n+! zIqnd=qC4aHS+khD->`#H99nv&z-A}^M7L4>aH}M3p(vc8D%BO2bU(qcvxA{@t`fiW zp=^+;n$5*PJT3#%K5S}GhX00UpKrM!2M#j=WF~$ESpn9iXRSomhIfz>1b+0cXvW{! zO#LM%Q&`T6vGK?-$+=~;o7BiUdwSu`HI)g(#hs<$k4%C=Thc;O0S~GP=Dpsqh*|ak zeOD|iOoLMFKOlP90E;sX_1i4Yf0Dbq7k%PmRr2tVD4-}~KuN%I-V3ER?MH886JR-v z-A`~EUtsX%cGyjDm2c=7CO_$;mtRI)} zBRjd#KMroz9{A!%8LnWEVFUk*b^tCB_^7-vy~}Uz%~<-a1d$;15*<)vOM;Oq2pXC= z*++Dsa#{n@cB=BdnA`Tpivg=WIP<>!ZnvaNUadtmzrm2o9(<AK|8P*-Xclrrtw=^|9(SFH%^9bJ9Gn)wflBLJ~4uv4%0EUNDGk%%(CkQF0zqWZ1ihlJ+q5LZ1i75 z!77LVMk&tvZ$z%HD4p33?j~M@R+Cm4OY1T|8X!V=|~Jn5ZWT=`;Ces|wMb%0f@ zr@EfBW+fbEm{=hrJEWkgjP&(xc{5yEe=_X5XF@cqJg94hh;miU!j~154n$NSq&a^|^A;(#8dn6j)f1h__Eg^8D z(uLHkAeY2OtlhwwA56{ugSV9Q@)T8Q>p)V@w3ib|Ivfs+&c*yY%lmwLSC}`|TxHQp`Mj$6!ZQ2OMpm6w{|Po4o`$Fnezl>H zpbwY2Ke0jh>3ZLb4UT!QM9q&RBMRLWC`6$*`|Gc$gN?&Wm#yW`jy_dD+!PR#zfF=C zv+DWrC@n^@-16srq%jOb8-V^^?Kya@F0ut~KWFxLn5TbL!M&2sE$PeZb!((PASaMH zQDWVvL^m)iFfhvT33lO3xdizL<7;WbK2?~nOI_0)&cTqvOaF9RKkI!{{!RICNLlQa z+mKVHsEWz!HP3!(v)*uwjsH^ z7wv$nMh|VKlw=0)6w-39V5lzbb6w#HyxH%U2Y6GnaoTukxn~k-;@_TYiwZC#I}X zCN{i#cU>e?Ltfot48b9aXa9EdO|9rgaTp?^bBmsAasl`4-ksbL8LN5Bz3_3yU^!jk64qS* zGN`--v2qree~yf*t?BUYN&KXkd|h6mH6KqbX8)+NzBDw5fGr>P1G|XLWItohX01VE zG_8k)6x}Y4FF89_Iwe$My#rUZfZD-7Se>Fg^O1VQ_TS(ECxh=MpJ219m(OB5pTH6; zL7k9Ic`^kFi4LUdv`(#Ouzh)m{3CJx~Aq##JB& z)4TWb>mq-GLy%o!WF5v~gLMc^a1npS%Bd17=K`s&!_;!V|JoDu#UHyzCWhEby2Ogg z31_rJUaBIyd*)0EV+eTzA2f!#}(p~TUU zK(tEEYzwdjl|@nwo&otwxHtKgq#WBRvdm;aTx-)$odBMHcJmjiXf`99Ji|&Gh~KOw z*FBXPFC-dgMa+@j7*_Ni&6&ex->9i{ZCsZo`>)iBRheLAq2=A6ZdNI|WK;4_(SZHc zoIOB#$ZsFKoG8_n!jXjf`MGUR$S0>08CHYV#Fhj=R0 zIrq8~PyeEBb63`tCTQ;+vaaOX5XLZj`2-y#TsTSBQU2+e!DLxV#BsVSr7R&|vv6caiM zerCB!S6L6EhZn30cBw$;W=CYKm8K3rp+GVw`5Tld`t!9^L!Wby=9y>A+h{{osabJL zLS89^kO=-*LFBI<>vCRDTiCpQUv6;vy}DQtw`Lg)5@tUYaKh{VPibcz7WLNkeFX(U2UMifC+>N~cJ7cZ`UF zA_4~89YaWWt03K-(w)Ny!@#?L;CZg+oZI`6>w3>0UT1XX7dzHod#$yjl}= zCNFsABA*AC4FcfD!2utP>3iN5J8M^K#R<0YV9tMS&kL?vqIxPpv zD#6z4^kc%owB}6==MvYR2p#M%9Tq#$T0d5rJ8XzGu+d#$Vx&%byUpPDdf?474%H6> z&FyKsh)0UApS>Y|RCC#FE#Vtbc6#*S%j>wO3a-IpXF|$e?2gY(khhOSmpySb+_BSU zbu_f(L5-lI!>Oa!1SP6sIdx{4Rd3w9sUe2Apnm;sjgIGyyUz34tXaJ2wYAnOv9#_# zl-kfenT`nOQeD34_~Fp#6n1sCzR`xUVy{#1*Ao5oXeySf37NrSQA)S@5=)}offAd1 zO{cArnvG{JEA!uq$2s^FlDj+tg_!s~- zp5$a_%|sO6n<_cOb~QSb&}L@$R7`nm1lNZ)v_lX!8p-tJ5(~L(%M4PFGz^ANka{T*hCY&I#SQGdVjvM zui#lE4$0{42#0Zyx+|oOj`3`(5OeKUJm_5yEy_u4|3n`ztAJXa&Jx1t%SXJwa`}7TgdeZ2{=0&v&e0sUKrHO%9GPl z<>lF`HNmMpzTKDYXk6|3OeWjU^ zD&(4(dL1e$n!Cjmc#>J+x&nSDUySD<>j7E6n*zJnr`m(ST16Kc+TG=Tzwxz2R)M z#QiY8^Z@MIKPo@e*sRANw&=);iLFXCkyO)Q&wS?LvAFSrIu_6~-;(gld~@-klwcoQ zt4Bs>&Ja3#^{8pHDGfVlKTXpOs|m`cb!$(Y4J6;LqU7&se_>ULem_4KtE!&&!gqD4 z4Q5*2%{1<^)cbfe@}MF?BX6AhGDgM(+is&|9vxN{YhqXLeIRJRs1Lj1W42lq4=`u; zT3LDwKs{@}l5*i_{45=~zTp@t7inzP83Vf1u|#JGMYUN-ep8+qtW1Xh;%c4iKxvIY zk?(?1ZwC;~Pzk>s%D7?|O$1dkvEK)Y6CJx{$Aqc1Jr2FoDBE9C{rW4Ow$cpAcE`YI?lu>FIxkl5aOMGD#o21r5kjw)qK9 z+aGvtb&c8YD|7laa>}{5lfoni+IFZ{xE_D4w~rAmu(|bYGRHD?t#dNMV`Y9%j(S+S z(DbaA?3&v=c}~~ReWI@N-96oB2-l*`v7DTr&AW!>8#xusv4=(xcu(iuzUs-pLt**l zw{ETML`t05^P7dk16_ZJYVI%xoc50cm)ueoTSt>@2?a=d$+A;YK$jNdZh)UbY&atpqx z!0Nlr%X+B3QEtU`w#aM*CNsVrPqO|X84QI9n7*9tuFyu$1}F9%1|-iuysIW*V| z$r_$sTv}tp#Rq{3l?FQrq>dH-oJ2*F%@6~-^E_=ipLiu4J%C&3r-f*Jrr{++TjKTQ zQa#IhM%Y>T^7P@7?vyfc#={6(*wntCx<7cM*P@_u@0%O@WIk)F2N=WWS2th8f{^CZ zK2R$cTk%}{iQPCRUS}te1{IX4TKbL25pA7%liBL?way9M?;%+!36TUWL!UZ}{j21a zbJUF5u4}G;u4pe+eIW~-CS$C$_OmD+bq>a(8fw_tDU1B}{hMrLYdvs)N0*3Oo3eTw zs<;iTidm>zoiF1J4{p76q`d7M)@JvbtL*_3M}_s^dSvTWd)H2z#GH4IB|%H{auL^Z zDh}lHEkAL?wwQ|#M`bh?mCxAKm+~rYy(=EQK3thzX%YM-h}u_ezG`h`MOKd@L(J8R zpsIHd)5 z8SiQ+Dh;OpsI;K~B5S>As-u;=h;J=47|}=Z z@qPVaEQe)*lcu1h^Jk=BtHD6>Aw5yWsU?JVP;ZfSZ0?AMD3CNdG%w9gzd)0+h06AT z`R*}=;1Lr(!9=N+TY8UhENXA{tPCR%Q7%JoW(9?Qw@x#p3X6lZ!^O121Wwom)36R4 zJk0R0;Bpqc5`9n6xl=1P0}T<_2lI`ZGu852t^zut(854&qRL8~VFp2Xk0(;Pgh=k5 zh+$jQZI8X}_dpMIz#aKF> zkPjanEKTiAEx`I%#9L_Qs#KJ5wom*#jcLh!QIa7!G-kuL=0E@&J;Y~umKg5b4try) zAda}P7l}4-x>j4Sap;)rR8;#mYU#oY@)t@UW zRXS7HB%ed0wVY9tg*M0$a{jqK#rhhDzwp(0PGjMzlt-vDDdmo$-es{GUec*#eWu2R z9we)wt7U=1zLfr%v$6{rA(ot6qhnl!>jxqCGu(QIM)XSB8#X<^o2IsOn{5=o4}B<* zQx;sErCzCQSvhr3^9&A-sLVx`S5v;kqv|N1!m)L8A(m{%dol zUD4ln_?TM5<-B=UDghkK((1zd*x+Od+V=T9s(oKnC(|J4GH`dX4iI z87OpLV0?uq3C#rz_UhXDrhAHgy?z6&+e<2&f#*R~>Ufq2l)MIZ&QLtkUMR41vX;KG zf2e=VOfJ&1s`MbDIt)L(0q63a#t)Oo+a|sDn(-Q_4Sc^b|E@Uj=9R{Q3Ej;2dH_)O zg;DM07%}W^(_SBIxNF!Fbm_WySch(!N4e7)i_@4(s{Q=>k|I352r+M<{^~J8dT0mC z8tMM*+TJ_Myp|wd;nf5VSt!Uz&NEuMmWJwhaI<~Q^&HITwknGk$$HA|KE2}gG(nlT zYw^D26Zxz#ihfRPQP#Aj)UW3&J_ zS)XLr+t4zt1Ab8E?b(UwHpm(O+_}64)JuOTWx2N^w9{K((&lW`1&)0huypG|oZHP( zA@AY>%R}=v*`jenT6-vsHeGfWH+4Zcj>9aIT9JG3=;+8E+M01{VLLli$5xx};!`L4 zhD9gU665p{hjAjqC-8gStF$XSUJ^0EYIY=HtsI|ik-?-7Jv}|2atpLaT2*sjtmz>> zfI?`{>Y;A&2*F}{-l=sB{*zp-KtFs?9RAbWH`lrJG!1t}GN!a2@o=ir;LGRp-kIAN z5gl4bUSqhymk0HZygtUvkJlAYvi&>{D2)1S+_c+SGxW!UTX%SjX z)+t&N-}jKeP&isi$bWl_gz3&2@s5XGi$(uS7``tb>VY;rZ`P)se5HPwWnaPj3)TBC z*w=_H@3mnnKc*=$<+MNeM%vb_wTdHU?}xN&yEmw1u}be6qkeh^Lnsss8(V{6MhBY^ zr;Id!CyvBSPT_s5Y{%J>VJnc&$*ZMxt8lhL+BFcvD>*MZ3zoojcxJxnd6(IwZWJ+^ zuPe|Fv%NoH>7#Sk)paNjFZI}pCTvw~cGP9}_8m&iQbtt!_PM~%B;*wS?Xc3Yr)Xpa zAmI1nvV2Gr?BTIrdqgf!LNytk?VlKxvv&lS_{qp}51sO}J38VIR(s}(izss{nbutz zF#NNSMydzcTfIKG6HpY=8X2}QXYuq==&NCs{!(VOekDea!*(}0W5f*Rj$ifV61NuT zwN!TJG`)xYYon4tg4A>UO$91P9wtkhLouOtHRE*3b>}o}$v(TfDF3Z`Oa&E7+^Tt- z*6(t^RHR_8#q){fWf>Z$s`iTN24r7^GJ*wi1o8I`0q>s#C51% zAnf4&^&!FB%>F4zThy>yUU2uubm&=irK#7~1K7Gvkt@S0-vX#LQkFh^_#oV&fZ&je z6ulO;6@~{Ozq`C~+(C}%QCJf7jQ>557(eu6FkFrijCzC0yR1sWS zI!;rPCMhd*Jy_ttqF~v3kipd1F>|(i_b377)yjkabl=j2U|W6#AAn->rY zw0%f!evrCeFqMz_Sr2<7IQI;XYa!P+kjfyXv={A~?cwIc{X}}v3@DYP;AlIQX-9(d z+;3HqCgKIx3NnULS~X-2O_SRr!C-94BSt(xe{U&|H)Y*K^AC*zi zzaqSbSys&H${ZeHD`Bx3%gn`#E*t)0EA+nq%|UVdYcmO4?bJOQo2S*A(Bm_F@TXn-Q?r3zG0_$_zDlDV|wx&qv)8ht=txJy(v+Vv~}h5KhGx;`)x7^t1C6rnQ|CgU}yEBL;HU=dZCM`-F$5#Oytk71|oTd+!@ zs-OAr!d<<~8q`kkwXIHa?XSY{$SF))X*+rf*P;P4Yt6Ix+8aAEX$fVSG%;CVb-*Yu zfHHk5Gg|KW2?Wj94x{x_=jBuYCA9rb&G&uVhO8c*7PM%L!Xa#K+_&L()#Ig%K|p|- zn=EY`$RHDxVNqPXz@3!`BOJ20W-+JJpP_`PvH6jnL^g0cfDiB{Vl?eL#k>Rv_?Fpt zWNOFS%2*r}C4R#R4!y zLP@oqYqRmow5mNT@u*e-Y-X&-t2WsGS6EBo%~=L;;y$D~Q-^<%G#^>1@Tg=*hjj$? znrQWWVYJVt4`F%DnZyxfCy<8AqI_XU{j8n69bnK~j4Y(Au%jGxSe=Wl zI|););Oh#--K;OHC>*R5ggZxd)|Pr+S^40>hAhBY)+t%5y_lBp;zkzsV)ep>z|?(Z zQ)i{b0^1-i@Vn5g@%6+J-o1m*IA!mO^5um(&l`ngjqIavWAX9n7mGG<68CFySL!V& zT6&(RM`Miu5daG!m$p)oOWfzC0z}r}Gp`UaE|Z*xKWg+i+uL)lF;=XngDZD1z5PLa z8`PMXaZ1D9isMHvnjM;2Wjyg1D`oEd96hX3f`%GJhqvwO$j{|Xebsq5p|M!~45RX} zrRdlmqe>a&f_=7nd|%P|Ha?{?`^BfU5gJaWN?O*-6QTy|?|si$5G{Fw^_c?8bM!W48j%ySi76XUkOlx*^0`k-nX&E7JD#pv(T~>s8 z&}l64NhV@n`^OJd23R=!(}I7HxWZq?wR%+dF1k#udhjp1MONi3(1H=={E?c!$E36H za)iYsR*IuXiG~yJygqKv@|};Es`rgXQq=IoewL84LSWNM zuc@Lca64tLPbjD}Bzq#>O#oRk1ArSy(E7!q0uR8uVE|ErsMGiE~3-jWI zGUv6cHn-m|X84NwTzC(tD-pT`w1OiqFJhhy7<0ZIwyM^m@vv_%FaThwY)v=@xte~{ z9RxY+U*d}5LiEytx&?qWn90m<`ylAC_a%wlVNsDtd9^F~t)_MD**h!s;>6d3mOvHD zr&3P?m{M<+#xR1a_c6})nqCHKw-^tpTK!j_LWJDuB`#RANyiKnFD*3dw^a#8TUxXB zC^k9b!Y=MFjmMrnJGI?hpjXlH7H5a0a#K7%UD>nz2kYGMXiJuMcj&=JfJ)^&njK9G zA9vuDSi!Dz~qst+b);|FZU ziwrXz%XIiIVm|Co$2UayNjrugI(AK`Z^j$xr}7mo;nEaT?_NVfaTPB?Sd!L~QtTFY zmR#x_A~<0rW!TKwD5rAgL+2C?J0jrTHXV;=Tt;w%oT%S|fb2_mY%|gmzK_4wkoWdzn7pz#&B5~n4DXhdlh=_)G0pihYv&)QS=1w)3pn!qD`L+-z1GuN=bNjt(}LPe*s6g zrPf`D<6OKFH>O{cu{S--r*YZ78N^{bD}YEI9ru`H4o^mP-A8J_s#&C~$}6( zz?$m*^%{=t3)IlUqSC4J{RI*IpDz`kQAQM3weLm3IOaF2wQY0<`V-+ohf`oq z4uw`32`s&`!YH{SQF6^Bva*HZ8kJ4()%!slqGWn-zbM_u~s zz0wykN>g!d)r^F@#fptv*JV0p%&PA6PMJw>mzDLNxqkLLii-Ilb_Zox(k^GIu=>18 zV5UImjLO&E>t$DEF^R#~D}-aKllM@T1?>btUVt+;yfC9AYjYKcP;YlXXHH*d=|E`l z;hbHa6{5FXVywi7!6fxa z>NVTq7jdh6W_?VznJx%u{picm5Mw;Im?fvnulLQL{g7xF6qD=%GK4;$?P#YZW*2~R ztHu5tD;3<)#iBi-)^(S0LybX~A&@teEoQXr&6) zQPZ9@-PI++@~oZ7n827d077VSEUR2iwE&{qn?NgH+QudqpxgvS&|$E;{ecRXd?u~3 z9<=lhZ8Cr^b>$f}KmQJ-yjw~NZS|7UW4J9x{sPpuU@X>CiM>>2y$qDfcy`Vt*MlB= z^2ju@*q_#)ga}06>12+Cs^)?xplWA z<=xx6b~WT&3^4XAREmVMD2#3K%B%0@yaJg%Jf{8Gw_$#Z4b+MQnt5Mk=(F^?83GQ3 z7$o&GlaqxWF31bHR7-4CG5rP49dc-~;!k`$ah z&9064PZJaqpJN}@t>}d=ZOLQfx{P5(KjYNK9uABNmAjqMU+^fgQq<@3a?zyalijHN z21UkbtOCN>*`iN2--d7ePwc6oLmfwOw2B}>|2eDVBouj>6?bKzUG`8`o+}LvFJI(0M$E~(K zj}qC|&CRIP)x^W?>V}b!78H7A*va|uo!aP%-~tMXksXiZa_g>JQf&UJjqFv0ht5CU z&W}5g>!qu#sva^a|0t-S14t+CDs+mTOE4A5Xx>5(jR&4-dVPKcL;Jl^*Vn>%%!qbn z()&F=lGY3rq3a~BF)(}s%a5adupHmQ84VDm~P!@ZU9s)Z3kS|l6fu| z>zIAFEW2?BozorECCT#VRf2>((?PbQki9l7AErEG zSR(VSH4G4D&qnZ_T~}RmSOao4zEhSY=Wa~#ObW^JwH7G$=I;8e`Cl3>?@DxeloIXc05O)hpQ3-w5O1A-uad1baU2H9@_pdKImCnoLM1?c;= z%Z(Pxs`qDDZ2_+Fr9hFgvO5GLR3z}5;b*Phw}n8a_i;d}ae|ylmWPBXui%QWkFXg2 zOMD`q40p06M`9Nis`AX|FzQ9-+WI^}CK0+%&y_QGmmCtYqrU+n8BNNqI0Y zTxtGzc$b+iI$BQ2W%uUXt3^M9qZht&u7r3+j>grW+hh6Q&T{b2TNUHe7TUqu zS^m42<=xFOTq3M$c?p6;_+`tcbp_0T!P?Y%}0&w~txuTXAvuA(td;fRCKNr49 z425R23A2RL;zfo>7G29)U^ILEgC5&`EA)!OoiG|7{99!nHOAR+dh7a3s18@8<3g919M8;^g}$uFmROL!6d|t%nCquW~+Q)D~ev=$Sd~~9cImvj*){^r|P@I_R9m0R!gP`>~x9? zgDD+EO8k7m{;jqvU2`>&?_k5iIJ`1t7NRf^NBw z2N-m7TQpzm0c*wj3y_yu!4MN7$p8$oOf5_4mc%=Xn*y%eLBQ5D0stabt>mb1EGxKB zk(SL{;aBG#oG0Gv@6XoKh;iTip4QE-()iuFgAS-=h*0qh(;0e^A4cDl7u=Gf(f(g4t)cE{$KB&{TN(|Vt`DR? zyJFLEx^jk)o|d$LsSkG#{d0+Y{Na*EMDu6qL)O000haGr->b6sBxp1$gBEkW34?1T zXg*ALc4_gR`GASCZg6j&N9!Xa9J(sh0ON1@z7sL(x3)1C$^{|IO5%m#B^}D_7l?0d z>vT&F4>^eG_Ao8(KXk=o|Tcs z^wi^FzO{<$6kYa_Lt0Lw4!0_tm$Hf@o+bhu$vMTB&xJINQ?>eXquf?Yy%xgosFlC; z-afp8M-wt0AaDsR_+r{FD_Y^)@Z8;JBYw+Dg&Dh-3nWl&wgXpjhrW&+)hOJc`>Y3q zxrVcx-YQ?E+KjB9{w#tanrE)ka;Xk%XB_IYBukG#HN2Lf5fly(eD<_pv@V-gVD%~# z2&WR7mgM=-;az9h;MaqHW2W!_Px^F9+hLx@aInyf$1TG636a30me zyYYoc7AXYVpP89CYmsub4q%od42W*YoWnO6f^l06-Qe}eEs7WQ^;0IY*C_M$b*%t` z(yi1lO4ocSITZmOYd8krXG#HywzVGc0vjLFN9(Jc9TnUe(1SRvVFm{i@p9xC;5bG& z(7LaCEtjuViJ&)6dC3s3`x2st%vkR#Mtf>f#*5YmDG7n&JH0c{K9e)W#Zp6szpq~P zCd;j;lk-3J0fZHxHuL(_8tTpb%Aks9l17nbFa;-mvbe5p9raLq{@&qV`-idDCfgRk zbkf&RiKZ6S01V`3G}x4eA;NjFMBxsO{y4wUl%XR!o5$;HjO`tN|BdIe%mtdEJ3}V# z3qMTkA(vKu#A!s|Qe`9=Iy}9MgS20qH0e$`Yq2JH4}did#wuJOe^gkZGh5ziT_M$^ zZy`>UlTYq&_W~tXi=thR2dI>0l8xko6_&R|^Qi>zF8-C@268d;@xId_*~7h5aA=lY zD!%QkE)w7)oN~TovL49Ng-tGgn%vtraGjBcGP0R{6x#n>cQfHW35<)+0p34_fbb$Ayk5E zin`_aWbG-QTA1}`!y>X(>+L5aC=Gk6Mn7wT&W}$~E1K#P{s9ae#CP5tbs8W1%5FU& zJoQ6|W?&+e&yuX0mR~d9@Ljl{OJ{C8Jqr_=IJ0!dyf$c(3qw)Ev7nSGFNw1mQv0Z>?gW`K$t=-i8 z?jReG?6fxKHC66Zcb1S)U|XTHCN2im5`MQ{ZsrPzNi}q?#|x4c3w{#5eN^v1K$}m>PirMTk~_24*;wC(()og3)t-qv2N1d^Q|d#w3u?U%j>psogzEzYJ|Mh3wNr?o%>s^S#0+*emXA81hxVd!c{iRH7vjLlT+gxN|6!f=LK&F2L** zR|f-L^@HUfRp`}^z>0)fZ0`UE_HuDqtXw`nAbq{|c&QN%-UTAOW>+7$+Tjepg63kuu@MG)XW23p8a< zXeG{HQ0IrMcCz#jtBSrn5WKIXYL8}K!vGSL287JZM}tAddR-#Gf1sD#C`y-MdqEud ze^D36*lNtzd~k&J*F`(iUx*euEcJZ{PQy(hAsq^COR9o5!@fRO-}?Ez=v%_(o=$7% z(0gU7{>EmeDY&cB&B+CDVX-6U!$90feXE5339~%l1_P()r7#?#25--IUI)&w@k||X zJ-I)((DDPIR-&3prK>|H{GbRhEy(X#$EhvTR>L)DpniJ;#Li_N1bUokR?!iiVF$H9 z%C!ER9BEGj4C6~%Bl$xS&r8c?zDLO_HC;kx<1;o1hfcXUB(V5%_@5b za!LM#Fui~nOkJQ&Yb+^_DwIVqng)x(rIpqd0`0nGxxWL3w=MzL`O6YLSO%1{dBq+8 zjbxu&4QPPTgnar08J1R4Y82qT(ZeXY?72e$L9r2FU#&u-9s1O4!Tt&-YYr+X4Pt`E z!iOZ<6B*C6zo4; zsmTGDa&}OzwTr4gw775UnD~~ZOcL7f(MAYQ02c5~3gMoV$$CIPm)jYK!v`zfis!G? z0TA8Or)Zn0Z{Gp489NZ!1}xSCY~LY{PpRExPK!McAxJBTeR4G;8zySK#YFvw%Ip`e z(Z{;yLF_yNp?&Lo8F&)NsVb2I$MimA*0373#>oZUOYR({AZ$(Jy18Ihrfg3l0}fm6 zwtv#DbPaC+;7ZQ^dK?iQ*M*x4{W-B}4bT*!8-x^Rn5E$V@aKQCxdMX=G^i!iL<}#g z7vphYh1cS7a0+i;zOb#r)l*fdqm?a78%QfOHX`3k2;4}(g>MW3rWpV|m^63b(Y&`xVrx68X z2H=D6!*Ir&#yv!IrL?lWq>((cVR|w*zbn+%zdBFaG-wpd%$sbRl=9^1lAUyFatc&m zlzt={skHatpT&5;w`E@T`1&A~?){uX(7*2o9^H_2JdD+6i7!U59(ifWHhT7F0N*Mb zF@fkxV()H&`nawyHHm4VT9H9Bi3{Lsx!H&+g+0XLWZ_BDJER8$Ib4JCjAd4Oj2x;jRY27@& zW)wr3m9B;6fQT5uWkC_pmGz>dF{=I)w5`6WQb$^g<5 znw5D`q$jy|umn^my~7TGwM}E3R|{&e*W{8MKnkec{4|VI+kN9JyWMQdYwTXOAJ+r< zuf3z-^edre1nY&DA5f!IeY8n+q(=G2S@Yp$5K*mYamM7&jVW0J(X(9(A048L6nZbV z;(O}9doGu{5A0GC;J~qhN~m-G<-mLFLa4AVjFuN08+@s&tE=H%g<3NF7U<#b>~m8m zlfQL7Ys=zHMlg}r%tC~bXoh*k!VlB{cJ`)HhT@%G*w*Hz?bMfh=RuFTfF9$4zu^%% z$vgmcNZ?q4r9r*5ivNV}J@SxaNn}X$khhTMmn7+b@9(1_k#rxr2EH9?)G0DO7+HmL zsc>Ptsc7L!3&-&zFsOseiRqjU2t3hfeuF*#{Px1Xd-j~_quPoR^qC+z%ZpbYdTYV@E>mRQKKkK|Ju4M9T=x+BT>PBQ$?r2&#x z49E#WlOzdJ+oj0mxpJakCOrV(mQr0fX8d|}fEN%g|9mpyZ=MAB?T#j+_>rLq!Un&! zo496+|A#I+dP+rG@Pfhncr^>hoep86T`PHho!I)r6>jK&Z*R&j9ILr`L2ASGU7wE- zdVickdC&`oX#V8`@SI?6rGy@Oir1Fp54SviXsB0$cNgtekG^d}3jB3PTY{5y@Iw;t zZGDBZBb1Ub-3MS_BzZHBKmFmUz09F?6{hm$&Qbhh+8_Kjs`OLTxs!BpurhezMYZbNo7eS}w`ZGNR$6FKCP{b^h)3<4{q{6A1YMPN$m z@n_~H{`9+}O9!0+H-0Fb1WZ5V<2?g1)?|n)!za1#bKw-AvD(tZSYLAVTU!Y1DyOY1 zcO<_3kEZ!g+v_ED6G(MG*0Pi%ff_e10cbWVZxc`aJlRu2@A%;C;Bhq1>mF!;Z(d(h zPWIdPpkwZC=CS>C)W@2Ta5q9FWa}h*_P9-G?(z3W9G!r^*mw%+HS0@cSbyv!sIhMV zEpxW3f{w?Nk4_N$c*7<4Xny>$m-Qi;@0Rjg{zs5cI$zLSv+G}Hdj7Lz|8uOS-2iXQ z`2E!^$IX^3~+ytj$cz@aD*CH%hFi@*+WSnRn2Z+!$d_36NEe#+x?lD23h z_5!i2?@%&5^LZq<6+x6T;9DnIj+S{flv?`&GO?yu+iB>1>CDbBh^||MWP6_FD6gF? zhqbDvrpy4FSxo$e6RfUug}7H zoSf&p@yuIdp3R~Cs_O}ieIv_hZubGe62JY|Uya#B=kBP#@V%;_`ts;egfq_A0*tQh zjMVMhw=YF&mx5h*`n4pTW0UcJw|bu3)7}gv!=V|dPeD8)&vO6ZG!g&y+jX*|LFIJ? zf7%qZg5yAnEG5*B_{0mp)7AL5Iq_P)JWyyB$^`OO7kEiCXfA`W=p1e0G2hJAOA`jP zQ$LG<;tYwxdM3ChyZfIX)~g3^Aj9|T*RPKi6+e|>C&wGT@HG*hy?ETRs?arAG>T-v zCh`^-gTdfg2fJsEtk=IE?w`{I{Hy1sfjon^KxOtmDC)S{8p+*mO8UZA&1090|7dkA z!UK(9UHjr}o*T+iH)6)zO`Ki(1W#;_H?R=0wY3FpFc)~ur2<6%*S1gC7COW!xA!J?3>QqmT6^Z45jp(R04j`t*<9UTJP=qML+JWTWvj%=*AF7{jZH0j#Ha+AeLBf9fNs%PxWb{rjLf zoh4{Gn~%BJCuu7l$jLEcxk>-a%h?03pVH1d^xko8j9JHXH+eAg;m2EDWe!Wm<)3Lz z@F-p{!4+pMb0JP>^Omd`hQgo)`#a5ve75wRH`6<(LbG{=1ua5id|7<~G#<+M9OscG?H-)f&YAM>xI=5o-t8v2( zXENE>$X^#w5C;uI{-K1#9b{e-ChHRtt}XPWe*{@2iN0(t${t@FLJ(2=3%S%!sJ<$w zT4tXP8Gfck5az}s9zwdl1Gy?(wLJYdJRw@y#hj)+L9?xqzA%QeVcXv&eE(&y=_;|* zksZoRR2;?%nz*rSx-SL=gX2X7z?QteZYiO&?uWnFWSX&Q9cf_JMC71bM<(;h3 zWsWNhFba-yr3awkmv~f#k&FNYG8H*`V4OW^v=5}Er0%a8krtT`J{~GC(WA9J!4@d! zDi+A~6BFu1vkYcAl36{yGu90<)H!6sM|*9$=g-4Q27CzN2fIdU<(?lOnGBWOLpXFH zYa4M0nL}{SQ*xT>Gmxx~ls?(6p8!qKx>#3te-M6%0i`nKfqU@1h1A)}F}F2lAPZN7 z01D&=?C^vAngeF_f*`O^M+(}z8fJY+n|xpaok0a-A{@Pc0?)AV!s#sMv`JBmTt!xU zQQuti*m<>-B{cFu1G&W^F`_SAcE?gdB||a&S(QqAbMtw3iP$+0p2KS6=>IVl&xk(9 zi&oxrCW{O&52oa2VgWLSBAAJ1k!5n>>|#Y$OD)thJ7CMXi z#qYg#0$>H_uLFOZvNY$g3A-8?4UKip>BpefiCy3TBxdrS)?(%J_t-aED%Cq9K#W_I z+Pes3d8AV1qFX#pKpZ`%A0o{3gk{*G>(N5T;zj;~%g2Qhz#VSEQsnm!XPEZk0->(5@Y}wWg|H7hU6GY7P){w&i=IKxp4Sg+`Bsd4u)WmD&R14h%kb2b^Xpv z{_F49<>}NpMT;4JfCNpKBd`(O;;mlC-)W=<2KkMaG$ntgPIZ<2+L(a8(W6ng z!nYghrEHqk3jLU$Q-KMX`GOW9%=X9Sp+adXX=(2OQp>}*cg`o-!s=qJq8e5|HCxWJ zMfVaAznIW{B|v?T?RZ5RWCUwYu34z@x;5CbKsEArUjr{p>MaTL3!DNEwBs%iw|G$e zw(lH`IMK5s{K3Ea^`9RVHn1!kJA4S~Wx}4~gsgVN(|nqUkDtT+wf-GbwzBeuZ&C1T z0%?I3;I7$^fFNu-$OTQ%@xI%fi-lWeTwSb-;53s0MYvEXA2_+#hvwFRn(#b;?~i6t zSp2+9tl(&iD{%V-I^h)JJsPlUDdm^=Ws2`L{0cAOLhGXAB_bG&=OG4_2ShdQz7{3m zd9b;;iG^(|ZQh@y(eGYk-@oL;JCi5ZoB3`cUU%Z}clhrnIcNhkb*>35*>H2U&52BLF5CfTKSI>N$kKD4V4` z>q7$shSyQO$^Y5M`o7Q6(bi%zx#q#=Xu#3qUtTC36pOp_?HPiIzcFH)H z#gHWEW$%DoSEOk;r&)*^xEY@bs37Us1E|18kXdFN3giOyVEp`lHc9N-!u23W2m+n`7=^haO0+6MuWB}9>Y^0hjt}eZqNdfRbZ|9dF^u=uq!F-&pbV= z%*QI!LYOsffqj)15)hZKjGQ3q{u+wn`YV|K-9FX86WQ-g;745sN@|>0bZoh4qdjDli2E)=NSG-n{`1CE31_WUJV9j&zBOYonQ zzBQkk$};2Pgw=~JE%x@dyX76;Um+!x4rS3gnIWUQ_!f*J)lUO|R}j4b;~2*#X{B~& zWq78UwVI>BtT!WgzS`IVB&7578VJCyFGCTbEDHv9!b+X%pSL}y&s>9Exv^gA*LTl> zSQ6VOsl`wrkR)Z;9%Dg})Jssfc=ZUm_pinN-ygl~A)Mnsr=4<(Skzskfbjcjfu8HN zxYFPZ_16n86HnkSDw={Z9lW<`w|U%gpX9+H*d4h%x&*RfL149&0{xK;mZvw44F@Oa z+jF0!!39bO29CjdUQN)R2-6P-O~($>q;?Y^KlEJ?z5MY&#QMQWT8__5Lant#IJtw=O)_?#s0F6;+JP|CTGUv{I>0K7t}y93XOGPT!0 z@A@y-tN%Sx0K1Xx4F21Ht$)A$_^+_pMadK}u=P#5PLxj^gob2!HtBIhLYVIQ8Cy>0 z65u94SIk! zCNVLw+d|q5grL=e%eLPgE!fZH=~VtFm}OTaQ@mV0&wql#gtToe#|VR0#=y*6xpGCn z5U;jAv&#L#kqbvR40S|Wzb>dGdi?nD{oZMQ0&FZe7Qv*&-v^dRy7%CTi z{CG4eF|olK-mbXZdIxUZFRtq2+Y00_d>7}G1$!DOgfo>8A&NQL(H9e5{FVjruSsYt zCtU9X)lq=*#MdyY#fP(xlSSP+|Ca|L=`C!4N5fzM&JO|KR2$SnbkQ|m{nurF`>~Pf z?-+AZTpV3KPRPqnun1sX(>k6u7ZH$jfjSY4Zc)e1e7H!~adqT2P$MZql>AP-^51R< zozWR+o`P)?kU@jpWqitlL$LDonzQlEUq7dVVFllD4#QCIII%x*pgpWPEOe_ojoH&ZF}ZS4sbGO+PD2kh+sjsXKBEEVE;lBq3Brv>dH zZnoMSxBfaX;F}!(Zl>Q_Juh=82DYLSv~jf4)ei=+(OV{88y zvcXDu+b7s?gAu*}wGN9(z;WdAIY{OQrT&sv{6k~wmxG5iuYTcw6l?f*MDV}6;z!f! zBBZ`|?h48AG8)7H8a@3(@`+;W7bPLKvi(Cls^jmuk~(YVh?si;$4icl0Qm dict: - """Create request body for Model Armor API.""" + """Create request body for Model Armor API with correct camelCase field names.""" if source == "user_prompt": - return {"user_prompt_data": {"text": content}} + return {"userPromptData": {"text": content}} else: - return {"model_response_data": {"text": content}} + return {"modelResponseData": {"text": content}} def _extract_content_from_response( self, response: Union[Any, ModelResponse] @@ -119,11 +119,16 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): async def make_model_armor_request( self, - content: str, - source: Literal["user_prompt", "model_response"], + content: Optional[str] = None, + source: Literal["user_prompt", "model_response"] = "user_prompt", request_data: Optional[dict] = None, + file_bytes: Optional[bytes] = None, + file_type: Optional[str] = None, ) -> dict: - """Make request to Model Armor API.""" + """ + Make request to Model Armor API. Supports both text and file prompt sanitization. + If file_bytes and file_type are provided, file prompt sanitization is performed. + """ # Get access token using VertexBase auth access_token, resolved_project_id = await self._ensure_access_token_async( credentials=self.credentials, @@ -143,7 +148,14 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): url = f"{endpoint}/v1/projects/{self.project_id}/locations/{self.location}/templates/{self.template_id}:sanitizeModelResponse" # Create request body - body = self._create_sanitize_request(content, source) + if file_bytes is not None and file_type is not None: + body = self.sanitize_file_prompt(file_bytes, file_type, source) + elif content is not None: + body = self._create_sanitize_request(content, source) + else: + raise ValueError( + "Either content or file_bytes and file_type must be provided." + ) # Set headers headers = { @@ -189,57 +201,110 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): return await json_response return json_response + def sanitize_file_prompt( + self, file_bytes: bytes, file_type: str, source: str = "user_prompt" + ) -> dict: + """ + Helper to build the request body for file prompt sanitization for Model Armor. + file_type should be one of: PLAINTEXT_UTF8, PDF, WORD_DOCUMENT, EXCEL_DOCUMENT, POWERPOINT_DOCUMENT, TXT, CSV + Returns the request body dict. + """ + import base64 + + base64_data = base64.b64encode(file_bytes).decode("utf-8") + if source == "user_prompt": + return { + "userPromptData": { + "byteItem": {"byteDataType": file_type, "byteData": base64_data} + } + } + else: + return { + "modelResponseData": { + "byteItem": {"byteDataType": file_type, "byteData": base64_data} + } + } + def _should_block_content(self, armor_response: dict) -> bool: - """Check if Model Armor response indicates content should be blocked.""" - # Check the sanitizationResult from Model Armor API + """Check if Model Armor response indicates content should be blocked, including both inspectResult and deidentifyResult.""" sanitization_result = armor_response.get("sanitizationResult", {}) filter_results = sanitization_result.get("filterResults", {}) - # Check blocking filters (these should cause the request to be blocked) - # RAI (Responsible AI) filters - rai_results = filter_results.get("rai", {}).get("raiFilterResult", {}) - if rai_results.get("matchState") == "MATCH_FOUND": - return True - - # Prompt injection and jailbreak filters - pi_jailbreak = filter_results.get("piAndJailbreakFilterResult", {}) - if pi_jailbreak.get("matchState") == "MATCH_FOUND": - return True - - # Malicious URI filters - malicious_uri = filter_results.get("maliciousUriFilterResult", {}) - if malicious_uri.get("matchState") == "MATCH_FOUND": - return True - - # CSAM filters - csam = filter_results.get("csamFilterFilterResult", {}) - if csam.get("matchState") == "MATCH_FOUND": - return True - - # Virus scan filters - virus_scan = filter_results.get("virusScanFilterResult", {}) - if virus_scan.get("matchState") == "MATCH_FOUND": - return True + # filterResults can be a dict (named keys) or a list (array of filter result dicts) + filter_result_items = [] + if isinstance(filter_results, dict): + filter_result_items = [filter_results] + elif isinstance(filter_results, list): + filter_result_items = filter_results + for filt in filter_result_items: + # Check RAI, PI/Jailbreak, Malicious URI, CSAM, Virus scan as before + if filt.get("raiFilterResult", {}).get("matchState") == "MATCH_FOUND": + return True + if ( + filt.get("piAndJailbreakFilterResult", {}).get("matchState") + == "MATCH_FOUND" + ): + return True + if ( + filt.get("maliciousUriFilterResult", {}).get("matchState") + == "MATCH_FOUND" + ): + return True + if ( + filt.get("csamFilterFilterResult", {}).get("matchState") + == "MATCH_FOUND" + ): + return True + if filt.get("virusScanFilterResult", {}).get("matchState") == "MATCH_FOUND": + return True + # Check sdpFilterResult for both inspectResult and deidentifyResult + sdp = filt.get("sdpFilterResult") + if sdp: + if sdp.get("inspectResult", {}).get("matchState") == "MATCH_FOUND": + return True + if sdp.get("deidentifyResult", {}).get("matchState") == "MATCH_FOUND": + return True + # Fallback dict code removed; all cases handled above return False def _get_sanitized_content(self, armor_response: dict) -> Optional[str]: - """Extract sanitized content from Model Armor response.""" - # Model Armor returns sanitized content in the sanitizationResult - sanitization_result = armor_response.get("sanitizationResult", {}) + """ + Get the sanitized content from a Model Armor response, if available. + Looks for sanitized text in deidentifyResult, and falls back to root-level fields if not found. + """ + result = armor_response.get("sanitizationResult", {}) + filter_results = result.get("filterResults", {}) - # Check for sdp structure (for deidentification) - filter_results = sanitization_result.get("filterResults", {}) - sdp = filter_results.get("sdp", {}).get("sdpFilterResult") + # filterResults can be a dict (single filter) or a list (multiple filters) + filters = ( + [filter_results] + if isinstance(filter_results, dict) + else filter_results + if isinstance(filter_results, list) + else [] + ) - if sdp is not None: - # Model Armor returns sanitized text under deidentifyResult in sdp - deidentify_result = sdp.get("deidentifyResult", {}) - sanitized_text = deidentify_result.get("data", {}).get("text", "") - if deidentify_result.get("matchState") == "MATCH_FOUND" and sanitized_text: - return sanitized_text + # Prefer sanitized text from deidentifyResult if present + for filter_entry in filters: + sdp = filter_entry.get("sdpFilterResult") + if sdp: + deid = sdp.get("deidentifyResult", {}) + sanitized = deid.get("data", {}).get("text", "") + # If Model Armor found something and returned a sanitized version, use it + if deid.get("matchState") == "MATCH_FOUND" and sanitized: + return sanitized - # Fallback to checking root level + # If no deidentifyResult, optionally check for inspectResult (rare, but could have findings) + for filter_entry in filters: + sdp = filter_entry.get("sdpFilterResult") + if sdp: + inspect = sdp.get("inspectResult", {}) + # If Model Armor flagged something but didn't sanitize, return None + if inspect.get("matchState") == "MATCH_FOUND": + return None + + # Fallback: if Model Armor put sanitized text at the root, use it return armor_response.get("sanitizedText") or armor_response.get("text") def _process_response( diff --git a/security.md b/security.md index 2da073661c5..d126dabcc67 100644 --- a/security.md +++ b/security.md @@ -12,11 +12,6 @@ - For installation and configuration, see: [Self-hosting guided](https://docs.litellm.ai/docs/proxy/deploy) - **Telemetry** We run no telemetry when you self host LiteLLM - -:::info -āœØ SSO is free for up to 5 users. After that, an enterprise license is required. [Get Started with Enterprise here](https://www.litellm.ai/enterprise) -::: - ### LiteLLM Cloud - We encrypt all data stored using your `LITELLM_MASTER_KEY` and in transit using TLS. From c87e6a849ba2b0a3c727f90ff9b679da5e34772a Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:21:23 -0700 Subject: [PATCH 36/65] fix mcp_servers_from_path --- litellm/proxy/_experimental/mcp_server/server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/_experimental/mcp_server/server.py b/litellm/proxy/_experimental/mcp_server/server.py index b6259b385fa..2cf91c84dcc 100644 --- a/litellm/proxy/_experimental/mcp_server/server.py +++ b/litellm/proxy/_experimental/mcp_server/server.py @@ -662,7 +662,7 @@ if MCP_AVAILABLE: server_name = single_server_match.group(1) mcp_servers_from_path = [server_name] else: - mcp_servers_from_path = [mcp_servers_str] + mcp_servers_from_path = [servers_and_path] return mcp_servers_from_path async def extract_mcp_auth_context(scope, path): From 620370e40c1f23a6006adb7d144af2778d39bdbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luiz=20Renn=C3=B3=20Costa?= Date: Tue, 23 Sep 2025 18:24:10 -0300 Subject: [PATCH 37/65] fix: get metadata info from both metadata and litellm_metadata fields (#14783) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: get metadata info from both metadata and litellm_metadata fields * fix: implemented requested changes (metadata field doesnt always exist) * chore: moved get_metadata_variable_name_from_kwargs to callback_utils so it can be used on get_model_group_from_litellm_kwargs --------- Co-authored-by: Luiz RennĆ³ Costa --- litellm/proxy/common_utils/callback_utils.py | 21 +++++++++++++++++-- .../hooks/parallel_request_limiter_v3.py | 7 +++++-- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/litellm/proxy/common_utils/callback_utils.py b/litellm/proxy/common_utils/callback_utils.py index d52592952bc..fb7ada8ab10 100644 --- a/litellm/proxy/common_utils/callback_utils.py +++ b/litellm/proxy/common_utils/callback_utils.py @@ -1,4 +1,4 @@ -from typing import Any, Dict, List, Optional +from typing import Any, Dict, List, Literal, Optional import litellm from litellm import get_secret @@ -289,7 +289,7 @@ def initialize_callbacks_on_proxy( # noqa: PLR0915 def get_model_group_from_litellm_kwargs(kwargs: dict) -> Optional[str]: _litellm_params = kwargs.get("litellm_params", None) or {} - _metadata = _litellm_params.get("metadata", None) or {} + _metadata = _litellm_params.get(get_metadata_variable_name_from_kwargs(kwargs)) or {} _model_group = _metadata.get("model_group", None) if _model_group is not None: return _model_group @@ -365,3 +365,20 @@ def add_guardrail_to_applied_guardrails_header( _metadata["applied_guardrails"].append(guardrail_name) else: _metadata["applied_guardrails"] = [guardrail_name] + + +def get_metadata_variable_name_from_kwargs( + kwargs: dict + ) -> Literal["metadata", "litellm_metadata"]: + """ + Helper to return what the "metadata" field should be called in the request data + + - New endpoints return `litellm_metadata` + - Old endpoints return `metadata` + + Context: + - LiteLLM used `metadata` as an internal field for storing metadata + - OpenAI then started using this field for their metadata + - LiteLLM is now moving to using `litellm_metadata` for our metadata + """ + return "litellm_metadata" if "litellm_metadata" in kwargs else "metadata" diff --git a/litellm/proxy/hooks/parallel_request_limiter_v3.py b/litellm/proxy/hooks/parallel_request_limiter_v3.py index 8ef0a662ffe..b6b82e4b376 100644 --- a/litellm/proxy/hooks/parallel_request_limiter_v3.py +++ b/litellm/proxy/hooks/parallel_request_limiter_v3.py @@ -25,6 +25,7 @@ from litellm import DualCache from litellm._logging import verbose_proxy_logger from litellm.integrations.custom_logger import CustomLogger from litellm.proxy._types import UserAPIKeyAuth +from litellm.types.llms.openai import BaseLiteLLMOpenAIResponseObject if TYPE_CHECKING: from opentelemetry.trace import Span as _Span @@ -708,6 +709,7 @@ class _PROXY_MaxParallelRequestsHandler_v3(CustomLogger): ) from litellm.proxy.common_utils.callback_utils import ( get_model_group_from_litellm_kwargs, + get_metadata_variable_name_from_kwargs ) from litellm.types.caching import RedisPipelineIncrementOperation from litellm.types.utils import ModelResponse, Usage @@ -723,7 +725,7 @@ class _PROXY_MaxParallelRequestsHandler_v3(CustomLogger): ) # Get metadata from kwargs - litellm_metadata = kwargs["litellm_params"]["metadata"] + litellm_metadata = kwargs["litellm_params"].get(get_metadata_variable_name_from_kwargs(kwargs), {}) if litellm_metadata is None: return user_api_key = litellm_metadata.get("user_api_key") @@ -736,7 +738,8 @@ class _PROXY_MaxParallelRequestsHandler_v3(CustomLogger): # Get total tokens from response total_tokens = 0 - if isinstance(response_obj, ModelResponse): + # spot fix for /responses api + if (isinstance(response_obj, ModelResponse) or isinstance(response_obj, BaseLiteLLMOpenAIResponseObject)): _usage = getattr(response_obj, "usage", None) if _usage and isinstance(_usage, Usage): if rate_limit_type == "output": From f8c1f519c93f2f71e9a64cbd2ab0cade55f406e3 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:26:38 -0700 Subject: [PATCH 38/65] test_aaamodel_prices_and_context_window_json_is_valid --- tests/test_litellm/test_utils.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py index 618a2902540..16be35c5cd5 100644 --- a/tests/test_litellm/test_utils.py +++ b/tests/test_litellm/test_utils.py @@ -522,6 +522,12 @@ def test_aaamodel_prices_and_context_window_json_is_valid(): "input_cost_per_image": {"type": "number"}, "input_cost_per_image_above_128k_tokens": {"type": "number"}, "input_cost_per_token_above_200k_tokens": {"type": "number"}, + "cache_read_input_token_cost_flex": {"type": "number"}, + "cache_read_input_token_cost_priority": {"type": "number"}, + "input_cost_per_token_flex": {"type": "number"}, + "input_cost_per_token_priority": {"type": "number"}, + "output_cost_per_token_flex": {"type": "number"}, + "output_cost_per_token_priority": {"type": "number"}, "input_cost_per_pixel": {"type": "number"}, "input_cost_per_query": {"type": "number"}, "input_cost_per_request": {"type": "number"}, From d6c94066089d98f3ceecbb33310bdc56f8079557 Mon Sep 17 00:00:00 2001 From: Otavio Brito Date: Tue, 23 Sep 2025 18:31:04 -0300 Subject: [PATCH 39/65] update context cache param --- docs/my-website/docs/providers/vertex.md | 70 +++++++++++++++++-- .../llms/vertex_ai/gemini/transformation.py | 14 ++-- litellm/llms/vertex_ai/vertex_llm_base.py | 10 +-- 3 files changed, 78 insertions(+), 16 deletions(-) diff --git a/docs/my-website/docs/providers/vertex.md b/docs/my-website/docs/providers/vertex.md index 260cc55c2e9..b5e30bf4d16 100644 --- a/docs/my-website/docs/providers/vertex.md +++ b/docs/my-website/docs/providers/vertex.md @@ -827,6 +827,72 @@ Use Vertex AI context caching is supported by calling provider api directly. (Un [**Go straight to provider**](../pass_through/vertex_ai.md#context-caching) +#### 1. Create the Cache + +First, create the cache by sending a `POST` request to the `cachedContents` endpoint via the LiteLLM proxy. + + + + +```bash +curl http://0.0.0.0:4000/vertex_ai/v1/projects/{project_id}/locations/{location}/cachedContents \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $LITELLM_KEY" \ + -d '{ + "model": "projects/{project_id}/locations/{location}/publishers/google/models/gemini-2.5-flash", + "displayName": "example_cache", + "contents": [{ + "role": "user", + "parts": [{ + "text": ".... a long book to be cached" + }] + }] + }' +``` + + + + +#### 2. Get the Cache Name from the Response + +Vertex AI will return a response containing the `name` of the cached content. This name is the identifier for your cached data. + +```json +{ + "name": "projects/12341234/locations/{location}/cachedContents/123123123123123", + "model": "projects/{project_id}/locations/{location}/publishers/google/models/gemini-2.5-flash", + "createTime": "2025-09-23T19:13:50.674976Z", + "updateTime": "2025-09-23T19:13:50.674976Z", + "expireTime": "2025-09-23T20:13:50.655988Z", + "displayName": "example_cache", + "usageMetadata": { + "totalTokenCount": 1246, + "textCount": 5132 + } +} +``` + +#### 3. Use the Cached Content + +Use the `name` from the response as `cached_content` in subsequent API calls to reuse the cached information. This is passed in the body of your request to `/chat/completions`. + + + + +```json +{ + "cachedContent": "projects/545201925769/locations/us-central1/cachedContents/4511135542628319232", + "model": "gemini-2.5-flash", + "messages": [ + { + "role": "user", + "content": "what is the book about?" + } + ] +} +``` + + ## Pre-requisites * `pip install google-cloud-aiplatform` (pre-installed on proxy docker image) @@ -2736,7 +2802,3 @@ Once that's done, when you deploy the new container in the Google Cloud Run serv s/o @[Darien Kindlund](https://www.linkedin.com/in/kindlund/) for this tutorial - - - - diff --git a/litellm/llms/vertex_ai/gemini/transformation.py b/litellm/llms/vertex_ai/gemini/transformation.py index c59e3bb24e8..ccaf28e5906 100644 --- a/litellm/llms/vertex_ai/gemini/transformation.py +++ b/litellm/llms/vertex_ai/gemini/transformation.py @@ -537,7 +537,11 @@ def sync_transform_request_body( logging_obj=logging_obj, ) else: # [TODO] implement context caching for gemini as well - cached_content = optional_params.pop("cached_content", None) + cached_content = None + if "cached_content" in optional_params: + cached_content = optional_params.pop("cached_content") + elif "cachedContent" in optional_params: + cached_content = optional_params.pop("cachedContent") return _transform_request_body( messages=messages, @@ -584,7 +588,11 @@ async def async_transform_request_body( logging_obj=logging_obj, ) else: # [TODO] implement context caching for gemini as well - cached_content = optional_params.pop("cached_content", None) + cached_content = None + if "cached_content" in optional_params: + cached_content = optional_params.pop("cached_content") + elif "cachedContent" in optional_params: + cached_content = optional_params.pop("cachedContent") return _transform_request_body( messages=messages, @@ -649,5 +657,3 @@ def _transform_system_message( return SystemInstructions(parts=system_content_blocks), messages return None, messages - - diff --git a/litellm/llms/vertex_ai/vertex_llm_base.py b/litellm/llms/vertex_ai/vertex_llm_base.py index 0f0bc776cc9..6d194d41add 100644 --- a/litellm/llms/vertex_ai/vertex_llm_base.py +++ b/litellm/llms/vertex_ai/vertex_llm_base.py @@ -271,17 +271,11 @@ class VertexBase: def is_using_v1beta1_features(self, optional_params: dict) -> bool: """ - VertexAI only supports ContextCaching on v1beta1 - use this helper to decide if request should be sent to v1 or v1beta1 - Returns v1beta1 if context caching is enabled - Returns v1 in all other cases + Returns true if any beta feature is enabled + Returns false in all other cases """ - if "cached_content" in optional_params: - return True - if "CachedContent" in optional_params: - return True return False def _check_custom_proxy( From bb6fb445c0d9d42d8a41822d2b99d1f88e303625 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:34:08 -0700 Subject: [PATCH 40/65] ui test fix --- .../proxy/management_endpoints/test_ui_sso.py | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py index 80aebc98497..4ccfca14f49 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py +++ b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py @@ -1303,7 +1303,7 @@ class TestCLIKeyRegenerationFlow: ) # Assert - mock_create.assert_called_once_with(new_key) + mock_create.assert_called_once_with(key=new_key, user_id=None) assert result.status_code == 200 assert "Success" in result.body.decode() @@ -1320,8 +1320,17 @@ class TestCLIKeyRegenerationFlow: # CLI state cli_state = f"{LITELLM_CLI_SESSION_TOKEN_PREFIX}:sk-new-session-key-456" - # Mock the CLI callback - with patch("litellm.proxy.management_endpoints.ui_sso.cli_sso_callback") as mock_cli_callback: + # Mock the CLI callback and required proxy server components + mock_result = {"user_id": "test-user", "email": "test@example.com"} + + with patch("litellm.proxy.management_endpoints.ui_sso.cli_sso_callback") as mock_cli_callback, \ + patch("litellm.proxy.proxy_server.prisma_client", MagicMock()), \ + patch("litellm.proxy.proxy_server.master_key", "test-master-key"), \ + patch("litellm.proxy.proxy_server.general_settings", {}), \ + patch("litellm.proxy.proxy_server.jwt_handler", MagicMock()), \ + patch("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()), \ + patch.dict(os.environ, {"GOOGLE_CLIENT_ID": "test-google-id"}, clear=True), \ + patch("litellm.proxy.management_endpoints.ui_sso.GoogleSSOHandler.get_google_callback_response", return_value=mock_result): mock_cli_callback.return_value = MagicMock() # Act @@ -1329,9 +1338,10 @@ class TestCLIKeyRegenerationFlow: # Assert mock_cli_callback.assert_called_once_with( - mock_request, + request=mock_request, key="sk-new-session-key-456", - existing_key="sk-existing-cli-key-123" + existing_key="sk-existing-cli-key-123", + result=mock_result ) def test_get_redirect_url_preserves_existing_key(self): From 3f50196acf4adc7260c587206d8ae9e62cbed047 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:40:11 -0700 Subject: [PATCH 41/65] test fix --- litellm/proxy/client/teams.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/litellm/proxy/client/teams.py b/litellm/proxy/client/teams.py index 61ddbe6adae..4f54b6bbd07 100644 --- a/litellm/proxy/client/teams.py +++ b/litellm/proxy/client/teams.py @@ -1,6 +1,6 @@ """Teams management client for LiteLLM proxy.""" -from typing import Any, Dict, List, Optional +from typing import Any, Dict, List, Optional, Union import requests @@ -99,7 +99,7 @@ class TeamsManagementClient: UnauthorizedError: If authentication fails """ url = f"{self._base_url}/v2/team/list" - params = { + params: Dict[str, Union[str, int]] = { "page": page, "page_size": page_size, "sort_order": sort_order, From 8016bcb1b9e4e7b613dff83b99e1ae7ade460cf5 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:41:30 -0700 Subject: [PATCH 42/65] test fix --- tests/test_litellm/test_utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py index 16be35c5cd5..09a03cc69c9 100644 --- a/tests/test_litellm/test_utils.py +++ b/tests/test_litellm/test_utils.py @@ -607,6 +607,7 @@ def test_aaamodel_prices_and_context_window_json_is_valid(): "supports_web_search": {"type": "boolean"}, "supports_url_context": {"type": "boolean"}, "supports_reasoning": {"type": "boolean"}, + "supports_service_tier": {"type": "boolean"}, "tool_use_system_prompt_tokens": {"type": "number"}, "tpm": {"type": "number"}, "supported_endpoints": { From 8d42eccc8a36181b0591adcd5c6a1c7f6c085345 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 14:44:41 -0700 Subject: [PATCH 43/65] =?UTF-8?q?bump:=20version=201.77.3=20=E2=86=92=201.?= =?UTF-8?q?77.4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 81104d072ee..dc22000f457 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "litellm" -version = "1.77.3" +version = "1.77.4" description = "Library to easily interface with LLM API providers" authors = ["BerriAI"] license = "MIT" @@ -157,7 +157,7 @@ requires = ["poetry-core", "wheel"] build-backend = "poetry.core.masonry.api" [tool.commitizen] -version = "1.77.3" +version = "1.77.4" version_files = [ "pyproject.toml:^version" ] From 2e7d9d18227db7fc6ae39fa1a5cfd15c2ec94f0f Mon Sep 17 00:00:00 2001 From: Otavio Brito Date: Tue, 23 Sep 2025 19:09:03 -0300 Subject: [PATCH 44/65] update example --- docs/my-website/docs/providers/vertex.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/docs/my-website/docs/providers/vertex.md b/docs/my-website/docs/providers/vertex.md index b5e30bf4d16..88f1cd6643f 100644 --- a/docs/my-website/docs/providers/vertex.md +++ b/docs/my-website/docs/providers/vertex.md @@ -874,13 +874,17 @@ Vertex AI will return a response containing the `name` of the cached content. Th #### 3. Use the Cached Content -Use the `name` from the response as `cached_content` in subsequent API calls to reuse the cached information. This is passed in the body of your request to `/chat/completions`. +Use the `name` from the response as `cachedContent` or `cached_content` in subsequent API calls to reuse the cached information. This is passed in the body of your request to `/chat/completions`. -```json -{ +```bash + +curl http://0.0.0.0:4000/chat/completions \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $LITELLM_KEY" \ + -d '{ "cachedContent": "projects/545201925769/locations/us-central1/cachedContents/4511135542628319232", "model": "gemini-2.5-flash", "messages": [ @@ -889,8 +893,9 @@ Use the `name` from the response as `cached_content` in subsequent API calls to "content": "what is the book about?" } ] -} + }' ``` + From 7e64df92a570ed1f0fd322c38f199d9e306ea878 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 15:42:07 -0700 Subject: [PATCH 45/65] test_cli_sso_callback_regenerate_existing_key --- tests/test_litellm/proxy/management_endpoints/test_ui_sso.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py index 4ccfca14f49..42873479ca9 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py +++ b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py @@ -1275,7 +1275,7 @@ class TestCLIKeyRegenerationFlow: ) # Assert - mock_regenerate.assert_called_once_with(existing_key, new_key) + mock_regenerate.assert_called_once_with(existing_key=existing_key, new_key=new_key, user_id=None) assert result.status_code == 200 assert "Success" in result.body.decode() From e0526c4554cd8e6128aefd3a9e10e717d88eba81 Mon Sep 17 00:00:00 2001 From: Ishaan Jaff Date: Tue, 23 Sep 2025 15:45:05 -0700 Subject: [PATCH 46/65] [Fix] Priority Reservation: keys without priority metadata receive higher priority than keys with explicit priority configurations. (#14832) * add PriorityReservationSettings * add priority_reservation_settings * add _get_priority_weight * docs update --- .../docs/proxy/dynamic_rate_limit.md | 20 ++++++++++++++++--- litellm/__init__.py | 2 ++ .../proxy/hooks/dynamic_rate_limiter_v3.py | 2 +- litellm/types/utils.py | 15 ++++++++++++++ 4 files changed, 35 insertions(+), 4 deletions(-) diff --git a/docs/my-website/docs/proxy/dynamic_rate_limit.md b/docs/my-website/docs/proxy/dynamic_rate_limit.md index 74a2d4c6c1b..b3aed6a359e 100644 --- a/docs/my-website/docs/proxy/dynamic_rate_limit.md +++ b/docs/my-website/docs/proxy/dynamic_rate_limit.md @@ -139,6 +139,8 @@ litellm_settings: priority_reservation: "prod": 0.9 # 90% reserved for production (9 RPM) "dev": 0.1 # 10% reserved for development (1 RPM) + priority_reservation_settings: + default_priority: 0 # Weight (0%) assigned to keys without explicit priority metadata general_settings: master_key: sk-1234 # OR set `LITELLM_MASTER_KEY=".."` in your .env @@ -152,6 +154,9 @@ general_settings: - **Value (float)**: Percentage of total TPM/RPM to reserve (0.0 to 1.0) - **Note**: Values should sum to 1.0 or less +`priority_reservation_settings`: Object (Optional) +- **default_priority (float)**: Weight/percentage (0.0 to 1.0) assigned to API keys that have no priority metadata set (defaults to 0.5) + **Start Proxy** ```bash @@ -180,6 +185,14 @@ curl -X POST 'http://0.0.0.0:4000/key/generate' \ }' ``` +**Key Without Priority (uses default_priority weight):** +```bash +curl -X POST 'http://0.0.0.0:4000/key/generate' \ +-H 'Authorization: Bearer sk-1234' \ +-H 'Content-Type: application/json' \ +-d '{}' +``` + **Expected Response for both:** ```json { @@ -217,9 +230,10 @@ curl -X POST 'http://0.0.0.0:4000/chat/completions' \ With the configuration above: -1. **Production keys** can make up to 9 requests per minute -2. **Development keys** can make up to 1 request per minute -3. Production requests are never blocked by development usage +1. **Production keys** can make up to 9 requests per minute (90% of 10 RPM) +2. **Development keys** can make up to 1 request per minute (10% of 10 RPM) +3. **Keys without explicit priority** get the default_priority weight (0 = 0%), which allocates 0 requests per minute (0% of 10 RPM) +4. Named priorities in `priority_reservation` and keys with `default_priority` operate independently **Rate Limit Error Example:** ```json diff --git a/litellm/__init__.py b/litellm/__init__.py index 7a68aa3a8d6..523ee36b865 100644 --- a/litellm/__init__.py +++ b/litellm/__init__.py @@ -89,6 +89,7 @@ from litellm.types.proxy.management_endpoints.ui_sso import ( LiteLLM_UpperboundKeyGenerateParams, ) from litellm.types.utils import StandardKeyGenerationConfig, LlmProviders +from litellm.types.utils import PriorityReservationSettings from litellm.integrations.custom_logger import CustomLogger from litellm.litellm_core_utils.logging_callback_manager import LoggingCallbackManager import httpx @@ -373,6 +374,7 @@ public_model_groups: Optional[List[str]] = None public_model_groups_links: Dict[str, str] = {} #### REQUEST PRIORITIZATION ###### priority_reservation: Optional[Dict[str, float]] = None +priority_reservation_settings: "PriorityReservationSettings" = PriorityReservationSettings() ######## Networking Settings ######## diff --git a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py index fef03d54743..38e211dea50 100644 --- a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py +++ b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py @@ -40,7 +40,7 @@ class _PROXY_DynamicRateLimitHandlerV3(CustomLogger): def _get_priority_weight(self, priority: Optional[str]) -> float: """Get the weight for a given priority from litellm.priority_reservation""" - weight: float = 1.0 + weight: float = litellm.priority_reservation_settings.default_priority if ( litellm.priority_reservation is None or priority not in litellm.priority_reservation diff --git a/litellm/types/utils.py b/litellm/types/utils.py index 01bf59fc841..afa545d7fb9 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -2633,3 +2633,18 @@ CostResponseTypes = Union[ ImageResponse, TranscriptionResponse, ] + + +class PriorityReservationSettings(BaseModel): + """ + Settings for priority-based rate limiting reservation. + + Defines what priority to assign to keys without explicit priority metadata. + The priority_reservation mapping is configured separately via litellm.priority_reservation. + """ + default_priority: float = Field( + default=0.5, + description="Priority level to assign to API keys without explicit priority metadata. Should match a key in litellm.priority_reservation." + ) + + model_config = ConfigDict(protected_namespaces=()) From 5fc70396ad301d0f99096937b1189f5f4a95f577 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 15:50:00 -0700 Subject: [PATCH 47/65] test fix --- tests/test_litellm/proxy/management_endpoints/test_ui_sso.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py index 42873479ca9..639b4756533 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py +++ b/tests/test_litellm/proxy/management_endpoints/test_ui_sso.py @@ -543,6 +543,7 @@ async def test_get_user_info_from_db(): assert mock_get_user_object.call_args.kwargs["user_id"] == "krrishd" +@pytest.mark.asyncio async def test_get_user_info_from_db_alternate_user_id(): from litellm.proxy.management_endpoints.ui_sso import get_user_info_from_db From 8443eff4a2bb78acea8685e5c34cdb554eb533cf Mon Sep 17 00:00:00 2001 From: Ishaan Jaff Date: Tue, 23 Sep 2025 16:01:44 -0700 Subject: [PATCH 48/65] feat: add xai/grok-4-fast models (#14833) --- ...odel_prices_and_context_window_backup.json | 29 +++++++++++++++++++ model_prices_and_context_window.json | 29 +++++++++++++++++++ 2 files changed, 58 insertions(+) diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 5ca0bf08ba9..2de3f07c618 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -21441,6 +21441,35 @@ "supports_tool_choice": true, "supports_web_search": true }, + "xai/grok-4-fast-reasoning": { + "litellm_provider": "xai", + "max_input_tokens": 2e6, + "max_output_tokens": 2e6, + "max_tokens": 2e6, + "mode": "chat", + "input_cost_per_token": 0.2e-06, + "output_cost_per_token": 0.5e-06, + "cache_read_input_token_cost": 0.05e-06, + "source": "https://docs.x.ai/docs/models", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_web_search": true + }, + "xai/grok-4-fast-non-reasoning": { + "litellm_provider": "xai", + "max_input_tokens": 2e6, + "max_output_tokens": 2e6, + "cache_read_input_token_cost": 0.05e-06, + "max_tokens": 2e6, + "mode": "chat", + "input_cost_per_token": 0.2e-06, + "output_cost_per_token": 0.5e-06, + "source": "https://docs.x.ai/docs/models", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_web_search": true + }, "xai/grok-4-0709": { "input_cost_per_token": 3e-06, "litellm_provider": "xai", diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 5ca0bf08ba9..2de3f07c618 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -21441,6 +21441,35 @@ "supports_tool_choice": true, "supports_web_search": true }, + "xai/grok-4-fast-reasoning": { + "litellm_provider": "xai", + "max_input_tokens": 2e6, + "max_output_tokens": 2e6, + "max_tokens": 2e6, + "mode": "chat", + "input_cost_per_token": 0.2e-06, + "output_cost_per_token": 0.5e-06, + "cache_read_input_token_cost": 0.05e-06, + "source": "https://docs.x.ai/docs/models", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_web_search": true + }, + "xai/grok-4-fast-non-reasoning": { + "litellm_provider": "xai", + "max_input_tokens": 2e6, + "max_output_tokens": 2e6, + "cache_read_input_token_cost": 0.05e-06, + "max_tokens": 2e6, + "mode": "chat", + "input_cost_per_token": 0.2e-06, + "output_cost_per_token": 0.5e-06, + "source": "https://docs.x.ai/docs/models", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_web_search": true + }, "xai/grok-4-0709": { "input_cost_per_token": 3e-06, "litellm_provider": "xai", From aaebd83f31b45520bfaf9bba7634672ac1122b89 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 16:07:01 -0700 Subject: [PATCH 49/65] test fixes --- .../proxy/client/cli/test_auth_commands.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/test_litellm/proxy/client/cli/test_auth_commands.py b/tests/test_litellm/proxy/client/cli/test_auth_commands.py index 5ef96e4f9af..0ea81c70eb1 100644 --- a/tests/test_litellm/proxy/client/cli/test_auth_commands.py +++ b/tests/test_litellm/proxy/client/cli/test_auth_commands.py @@ -159,13 +159,13 @@ class TestTokenUtilities: 'user_id': 'test-user' } - with patch('litellm.proxy.client.cli.commands.auth.load_token', return_value=token_data): + with patch('litellm.litellm_core_utils.cli_token_utils.load_cli_token', return_value=token_data): result = get_stored_api_key() assert result == 'test-api-key-123' def test_get_stored_api_key_no_token(self): """Test getting stored API key when no token exists""" - with patch('litellm.proxy.client.cli.commands.auth.load_token', return_value=None): + with patch('litellm.litellm_core_utils.cli_token_utils.load_cli_token', return_value=None): result = get_stored_api_key() assert result is None @@ -175,7 +175,7 @@ class TestTokenUtilities: 'user_id': 'test-user' } - with patch('litellm.proxy.client.cli.commands.auth.load_token', return_value=token_data): + with patch('litellm.litellm_core_utils.cli_token_utils.load_cli_token', return_value=token_data): result = get_stored_api_key() assert result is None @@ -471,7 +471,7 @@ class TestCLIKeyRegenerationFlow: assert result.exit_code == 0 assert "āœ… Login successful!" in result.output - assert "API Key: sk-regenerated-key-456" in result.output + assert "API Key: sk-regenerated-key-4..." in result.output # Verify existing key was retrieved mock_get_stored.assert_called_once() @@ -486,7 +486,9 @@ class TestCLIKeyRegenerationFlow: # Verify polling was done with correct session key mock_get.assert_called() - poll_url = mock_get.call_args[0][0] + # Check that the polling URL was called (should be the first call) + first_call_args = mock_get.call_args_list[0] + poll_url = first_call_args[0][0] assert "sk-new-session-uuid-789" in poll_url # Verify regenerated key was saved From bd0741fa22935ee3b6ec114c8d52eb741fb3a0e6 Mon Sep 17 00:00:00 2001 From: Alexsander Hamir Date: Tue, 23 Sep 2025 16:15:15 -0700 Subject: [PATCH 50/65] fix: cache root cause (#14827) * fix: cache root cause Ensure values are set and retrieved with the expected type to avoid unnecessary checks and cache misses. fix: undoing hard changes * fix: removed unexpected errors * fix: removed unnecessary changes --- litellm/proxy/auth/auth_checks.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 8a138b2a808..012876db481 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -469,7 +469,6 @@ async def get_end_user_object( # check if in cache cached_user_obj = await user_api_key_cache.async_get_cache(key=_key) if cached_user_obj is not None: - # Convert cached dict to LiteLLM_EndUserTable instance return_obj = LiteLLM_EndUserTable(**cached_user_obj) check_in_budget(end_user_obj=return_obj) return return_obj @@ -527,10 +526,7 @@ async def get_team_membership( # check if in cache cached_membership_obj = await user_api_key_cache.async_get_cache(key=_key) if cached_membership_obj is not None: - if isinstance(cached_membership_obj, dict): - return LiteLLM_TeamMembership(**cached_membership_obj) - elif isinstance(cached_membership_obj, LiteLLM_TeamMembership): - return cached_membership_obj + return LiteLLM_TeamMembership(**cached_membership_obj) # else, check db try: @@ -542,8 +538,8 @@ async def get_team_membership( if response is None: return None - # save the team membership object to cache - await user_api_key_cache.async_set_cache(key=_key, value=response) + # save the team membership object to cache (store as dict) + await user_api_key_cache.async_set_cache(key=_key, value=response.dict()) _response = LiteLLM_TeamMembership(**response.dict()) @@ -819,8 +815,9 @@ async def _cache_management_object( user_api_key_cache: DualCache, proxy_logging_obj: Optional[ProxyLogging], ): + await user_api_key_cache.async_set_cache( - key=key, value=value, ttl=DEFAULT_MANAGEMENT_OBJECT_IN_MEMORY_CACHE_TTL + key=key, value=value, ttl=DEFAULT_MANAGEMENT_OBJECT_IN_MEMORY_CACHE_TTL, ) From fff1d1a9f985a067b7af51e62a41373ec8f0a0f1 Mon Sep 17 00:00:00 2001 From: Ishaan Jaff Date: Tue, 23 Sep 2025 16:16:57 -0700 Subject: [PATCH 51/65] Add Vertex AI Qwen3 models to pricing and context window (#14828) Co-authored-by: Cursor Agent Co-authored-by: ishaan --- model_prices_and_context_window.json | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 2de3f07c618..99452eafefb 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -21189,6 +21189,30 @@ "/v1/audio/transcriptions" ] }, + "vertex_ai/qwen/qwen3-next-80b-a3b-instruct-maas": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "vertex_ai-qwen_models", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.2e-06, + "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true + }, + "vertex_ai/qwen/qwen3-next-80b-a3b-thinking-maas": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "vertex_ai-qwen_models", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.2e-06, + "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true + }, "xai/grok-2": { "input_cost_per_token": 2e-06, "litellm_provider": "xai", From fc1c39645a28bf65adab1038e7feffebb63de82c Mon Sep 17 00:00:00 2001 From: Mubashir Osmani Date: Tue, 23 Sep 2025 19:18:57 -0400 Subject: [PATCH 52/65] docs: Letta Guide (#14798) * fix: flaky passthrough tests * Revert "fix: flaky passthrough tests" This reverts commit ffe692e017600a8853ab7c31f95485958ab74c5f. * fix: serialize prisma objects * docs: added letta * arranged endpoints in alphabetical order * added user_api_key fields to custom auth docs * user onboarding * cleaning up This reverts commit 40e2aade73632cea371c6092d766ba193f9ac4a3. * cleaning up This reverts commit ffe692e017600a8853ab7c31f95485958ab74c5f. * Revert "fix: serialize prisma objects" This reverts commit 1e7bd13c26dcac8bff1f818c39b2b78f22f0ba28. --- docs/my-website/docs/integrations/index.md | 13 + docs/my-website/docs/integrations/letta.md | 928 ++++++++++++++++++ docs/my-website/docs/proxy/custom_auth.md | 163 +++ docs/my-website/docs/proxy/user_onboarding.md | 82 ++ docs/my-website/sidebars.js | 157 +-- 5 files changed, 1272 insertions(+), 71 deletions(-) create mode 100644 docs/my-website/docs/integrations/letta.md create mode 100644 docs/my-website/docs/proxy/user_onboarding.md diff --git a/docs/my-website/docs/integrations/index.md b/docs/my-website/docs/integrations/index.md index 9731db6e751..95c922cce89 100644 --- a/docs/my-website/docs/integrations/index.md +++ b/docs/my-website/docs/integrations/index.md @@ -2,4 +2,17 @@ This section covers integrations with various tools and services that can be used with LiteLLM (either Proxy or SDK). +## AI Agent Frameworks +- **[Letta](./letta.md)** - Build stateful LLM agents with persistent memory using LiteLLM Proxy + +## Development Tools +- **[OpenWebUI](../tutorials/openweb_ui.md)** - Self-hosted ChatGPT-style interface + +## Observability & Monitoring +- **[Langfuse](../observability/langfuse_integration.md)** - LLM observability and analytics +- **[Prometheus](../proxy/prometheus.md)** - Metrics collection and monitoring +- **[PagerDuty](../proxy/pagerduty.md)** - Incident response and alerting +- **[Datadog](../observability/datadog.md)** + + Click into each section to learn more about the integrations. \ No newline at end of file diff --git a/docs/my-website/docs/integrations/letta.md b/docs/my-website/docs/integrations/letta.md new file mode 100644 index 00000000000..2afb82542f2 --- /dev/null +++ b/docs/my-website/docs/integrations/letta.md @@ -0,0 +1,928 @@ +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; + +# Letta Integration + +[Letta](https://github.com/letta-ai/letta) (formerly MemGPT) is a framework for building stateful LLM agents with persistent memory. This guide shows how to integrate both LiteLLM SDK and LiteLLM Proxy with Letta to leverage multiple LLM providers while building memory-enabled agents. + +## What is Letta? + +Letta allows you to build LLM agents that can: +- Maintain long-term memory across conversations +- Use function calling for tool interactions +- Handle large context windows efficiently +- Persist agent state and memory + +## Prerequisites + +```bash +pip install letta litellm +``` + +## Quick Start + + + + +### 1. Start LiteLLM Proxy + +First, create a configuration file for your LiteLLM proxy: + +```yaml +# config.yaml +model_list: + - model_name: gpt-4 + litellm_params: + model: openai/gpt-4 + api_key: os.environ/OPENAI_API_KEY + + - model_name: claude-3-sonnet + litellm_params: + model: anthropic/claude-3-sonnet-20240229 + api_key: os.environ/ANTHROPIC_API_KEY + + - model_name: gpt-3.5-turbo + litellm_params: + model: azure/gpt-35-turbo + api_key: os.environ/AZURE_API_KEY + api_base: os.environ/AZURE_API_BASE + api_version: "2023-07-01-preview" +``` + +Start the proxy: + +```bash +litellm --config config.yaml --port 4000 +``` + +### 2. Configure Letta with LiteLLM Proxy + +Configure Letta to use your LiteLLM proxy endpoint: + +```python +import letta +from letta import create_client + +# Configure Letta to use LiteLLM proxy +client = create_client() + +# Configure the LLM endpoint +client.set_default_llm_config( + model="gpt-4", # This should match a model from your LiteLLM config + model_endpoint_type="openai", + model_endpoint="http://localhost:4000", # Your LiteLLM proxy URL + context_window=8192 +) + +# Configure embedding endpoint (optional) +client.set_default_embedding_config( + embedding_endpoint_type="openai", + embedding_endpoint="http://localhost:4000", + embedding_model="text-embedding-ada-002" +) +``` + + + + +### 1. Configure LiteLLM SDK + +Set up your API keys and configure LiteLLM: + +```python +import os +import litellm + +# Set your API keys +os.environ["OPENAI_API_KEY"] = "your-openai-key" +os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key" + +# Optional: Configure default settings +litellm.set_verbose = True # For debugging +``` + +### 2. Create Custom LLM Wrapper for Letta + +Create a custom LLM wrapper that uses LiteLLM SDK: + +```python +import letta +from letta import create_client +from letta.llm_api.llm_api_base import LLMConfig +import litellm +from typing import List, Dict, Any + +class LiteLLMWrapper: + def __init__(self, model: str): + self.model = model + + def chat_completions_create(self, messages: List[Dict], **kwargs): + # Use LiteLLM SDK for completion + response = litellm.completion( + model=self.model, + messages=messages, + **kwargs + ) + return response + +# Configure Letta with custom LiteLLM wrapper +client = create_client() + +# Set up LLM configuration using direct SDK integration +llm_config = LLMConfig( + model="gpt-4", # or "claude-3-sonnet", "azure/gpt-35-turbo", etc. + model_endpoint_type="openai", + context_window=8192 +) + +client.set_default_llm_config(llm_config) +``` + + + + +### 3. Create and Use a Letta Agent + + + + +```python +import letta +from letta import create_client + +# Create Letta client +client = create_client() + +# Create a new agent +agent_state = client.create_agent( + name="my-assistant", + system="You are a helpful assistant with persistent memory.", + llm_config=client.get_default_llm_config(), + embedding_config=client.get_default_embedding_config() +) + +# Send a message to the agent +response = client.user_message( + agent_id=agent_state.id, + message="Hi! My name is Alice and I love reading science fiction books." +) + +print(f"Agent response: {response.messages[-1].text}") + +# Send another message - the agent will remember previous context +response = client.user_message( + agent_id=agent_state.id, + message="What did I tell you about my interests?" +) + +print(f"Agent response: {response.messages[-1].text}") +``` + + + + +```python +import letta +from letta import create_client +import litellm +import os + +# Set up environment variables +os.environ["OPENAI_API_KEY"] = "your-openai-key" + +# Create Letta client with LiteLLM integration +client = create_client() + +# Create a new agent +agent_state = client.create_agent( + name="my-assistant", + system="You are a helpful assistant with persistent memory.", + llm_config=client.get_default_llm_config(), + embedding_config=client.get_default_embedding_config() +) + +# Send a message to the agent +response = client.user_message( + agent_id=agent_state.id, + message="Hi! My name is Alice and I love reading science fiction books." +) + +print(f"Agent response: {response.messages[-1].text}") + +# Send another message - the agent will remember previous context +response = client.user_message( + agent_id=agent_state.id, + message="What did I tell you about my interests?" +) + +print(f"Agent response: {response.messages[-1].text}") +``` + + + + +## Advanced Configuration + +### Using Different Models for Different Agents + + + + +```python +from letta import LLMConfig, EmbeddingConfig + +# Create different LLM configurations pointing to your proxy +gpt4_config = LLMConfig( + model="gpt-4", + model_endpoint_type="openai", + model_endpoint="http://localhost:4000", + context_window=8192 +) + +claude_config = LLMConfig( + model="claude-3-sonnet", + model_endpoint_type="openai", # Using OpenAI-compatible endpoint + model_endpoint="http://localhost:4000", + context_window=200000 +) + +# Create agents with different configurations +research_agent = client.create_agent( + name="research-agent", + system="You are a research assistant specialized in analysis.", + llm_config=claude_config # Use Claude for research tasks +) + +creative_agent = client.create_agent( + name="creative-agent", + system="You are a creative writing assistant.", + llm_config=gpt4_config # Use GPT-4 for creative tasks +) +``` + + + + +```python +import os +import litellm +from letta import LLMConfig, EmbeddingConfig + +# Set up API keys for different providers +os.environ["OPENAI_API_KEY"] = "your-openai-key" +os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key" + +# Create different LLM configurations for direct SDK usage +gpt4_config = LLMConfig( + model="openai/gpt-4", # Using LiteLLM model format + model_endpoint_type="openai", + context_window=8192 +) + +claude_config = LLMConfig( + model="anthropic/claude-3-sonnet-20240229", # Using LiteLLM model format + model_endpoint_type="openai", + context_window=200000 +) + +# Create agents with different configurations +research_agent = client.create_agent( + name="research-agent", + system="You are a research assistant specialized in analysis.", + llm_config=claude_config # Use Claude for research tasks +) + +creative_agent = client.create_agent( + name="creative-agent", + system="You are a creative writing assistant.", + llm_config=gpt4_config # Use GPT-4 for creative tasks +) +``` + + + + +### Function Calling with Tools + + + + +```python +# Define custom tools for your agent +def search_web(query: str) -> str: + """Search the web for information""" + # Your web search implementation + return f"Search results for: {query}" + +def save_note(content: str) -> str: + """Save a note to persistent storage""" + # Your note saving implementation + return f"Note saved: {content}" + +# Create agent with tools (using proxy endpoint) +agent_state = client.create_agent( + name="research-assistant", + system="You are a research assistant that can search the web and save notes.", + llm_config=client.get_default_llm_config(), + embedding_config=client.get_default_embedding_config(), + tools=[search_web, save_note] +) + +# The agent can now use these tools +response = client.user_message( + agent_id=agent_state.id, + message="Search for recent developments in AI and save important findings." +) +``` + + + + +```python +import litellm +import os + +# Set up API keys +os.environ["OPENAI_API_KEY"] = "your-openai-key" + +# Define custom tools for your agent +def search_web(query: str) -> str: + """Search the web for information""" + # Your web search implementation + return f"Search results for: {query}" + +def save_note(content: str) -> str: + """Save a note to persistent storage""" + # Your note saving implementation + return f"Note saved: {content}" + +# Create agent with tools (using LiteLLM SDK directly) +agent_state = client.create_agent( + name="research-assistant", + system="You are a research assistant that can search the web and save notes.", + llm_config=LLMConfig( + model="openai/gpt-4", # Direct model specification + model_endpoint_type="openai", + context_window=8192 + ), + embedding_config=client.get_default_embedding_config(), + tools=[search_web, save_note] +) + +# The agent can now use these tools +response = client.user_message( + agent_id=agent_state.id, + message="Search for recent developments in AI and save important findings." +) +``` + + + + +## Authentication + + + + +If your LiteLLM proxy requires authentication: + +```python +import os +from letta import LLMConfig + +# Set up authenticated configuration +llm_config = LLMConfig( + model="gpt-4", + model_endpoint_type="openai", + model_endpoint="http://localhost:4000", + model_wrapper="openai", + context_window=8192 +) + +# If using API keys with your proxy +os.environ["OPENAI_API_KEY"] = "your-litellm-proxy-api-key" + +client = create_client() +client.set_default_llm_config(llm_config) +``` + +For proxy with authentication enabled: + +```yaml +# config.yaml with auth +general_settings: + master_key: "your-master-key" + +model_list: + - model_name: gpt-4 + litellm_params: + model: openai/gpt-4 + api_key: os.environ/OPENAI_API_KEY +``` + +```python +# Configure Letta with authenticated proxy +llm_config = LLMConfig( + model="gpt-4", + model_endpoint_type="openai", + model_endpoint="http://localhost:4000", + context_window=8192, + api_key="your-master-key" # Proxy master key +) +``` + + + + +With LiteLLM SDK, set up your provider API keys directly: + +```python +import os +import litellm + +# Set up API keys for different providers +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key" +os.environ["AZURE_API_KEY"] = "your-azure-api-key" +os.environ["AZURE_API_BASE"] = "https://your-resource.openai.azure.com" +os.environ["AZURE_API_VERSION"] = "2023-07-01-preview" + +# Optional: Configure default settings +litellm.api_key = os.environ.get("OPENAI_API_KEY") # Default key +litellm.set_verbose = True # For debugging + +# Use in Letta configuration +from letta import LLMConfig + +llm_config = LLMConfig( + model="openai/gpt-4", # Will use OPENAI_API_KEY automatically + model_endpoint_type="openai", + context_window=8192 +) + +# Or for Azure +azure_config = LLMConfig( + model="azure/gpt-35-turbo", + model_endpoint_type="openai", + context_window=4096 +) +``` + + + + +## Load Balancing and Fallbacks + + + + +LiteLLM proxy's load balancing and fallback features work seamlessly with Letta: + +```yaml +# config.yaml with fallbacks +model_list: + - model_name: gpt-4 + litellm_params: + model: openai/gpt-4 + api_key: os.environ/OPENAI_API_KEY + tpm: 40000 + rpm: 500 + + - model_name: gpt-4 # Same model name for fallback + litellm_params: + model: azure/gpt-4 + api_key: os.environ/AZURE_API_KEY + api_base: os.environ/AZURE_API_BASE + api_version: "2023-07-01-preview" + tpm: 80000 + rpm: 800 + +router_settings: + routing_strategy: "usage-based-routing" + fallbacks: [{"gpt-4": ["azure/gpt-4"]}] +``` + +The proxy handles all routing, load balancing, and fallbacks transparently for Letta. + + + + +With LiteLLM SDK, you can set up routing and fallbacks programmatically: + +```python +import litellm +from litellm import Router + +# Configure router with multiple models +router = Router( + model_list=[ + { + "model_name": "gpt-4", + "litellm_params": { + "model": "openai/gpt-4", + "api_key": os.environ["OPENAI_API_KEY"] + }, + "tpm": 40000, + "rpm": 500 + }, + { + "model_name": "gpt-4", # Same name for fallback + "litellm_params": { + "model": "azure/gpt-4", + "api_key": os.environ["AZURE_API_KEY"], + "api_base": os.environ["AZURE_API_BASE"], + "api_version": "2023-07-01-preview" + }, + "tpm": 80000, + "rpm": 800 + } + ], + fallbacks=[{"gpt-4": ["azure/gpt-4"]}], + routing_strategy="usage-based-routing" +) + +# Create custom completion function for Letta +def custom_completion(messages, model="gpt-4", **kwargs): + return router.completion( + model=model, + messages=messages, + **kwargs + ) + +# Use with Letta by monkey-patching or custom wrapper +litellm.completion = custom_completion +``` + + + + +## Monitoring and Observability + + + + +Enable logging to track your Letta agents' LLM usage through the proxy: + +```yaml +# config.yaml with logging +model_list: + # ... your models + +litellm_settings: + success_callback: ["langfuse"] # or other observability tools + +environment_variables: + LANGFUSE_PUBLIC_KEY: "your-key" + LANGFUSE_SECRET_KEY: "your-secret" +``` + +View metrics in the proxy dashboard: +```bash +# Start proxy with UI +litellm --config config.yaml --port 4000 --detailed_debug +``` + + + + +Set up observability directly in your SDK integration: + +```python +import litellm +import os + +# Configure observability callbacks +os.environ["LANGFUSE_PUBLIC_KEY"] = "your-key" +os.environ["LANGFUSE_SECRET_KEY"] = "your-secret" + +# Set global callbacks +litellm.success_callback = ["langfuse"] +litellm.failure_callback = ["langfuse"] + +# Optional: Set up custom logging +litellm.set_verbose = True + +# Create custom completion wrapper with logging +def logged_completion(messages, model="gpt-4", **kwargs): + try: + response = litellm.completion( + model=model, + messages=messages, + **kwargs + ) + # Custom logging logic here if needed + return response + except Exception as e: + # Custom error handling + print(f"LLM call failed: {e}") + raise + +# Use in Letta configuration +litellm.completion = logged_completion +``` + + + + +## Example: Multi-Agent System + + + + +```python +import letta +from letta import create_client, LLMConfig + +client = create_client() + +# Create specialized agents using proxy endpoints +agents = {} + +# Research agent using Claude for analysis +agents['researcher'] = client.create_agent( + name="researcher", + system="You are a research specialist. Analyze information thoroughly.", + llm_config=LLMConfig( + model="claude-3-sonnet", + model_endpoint="http://localhost:4000", + model_endpoint_type="openai" + ) +) + +# Writer agent using GPT-4 for content creation +agents['writer'] = client.create_agent( + name="writer", + system="You are a content writer. Create engaging, well-structured content.", + llm_config=LLMConfig( + model="gpt-4", + model_endpoint="http://localhost:4000", + model_endpoint_type="openai" + ) +) + +# Coordinator workflow +def research_and_write_workflow(topic: str): + # Research phase + research_response = client.user_message( + agent_id=agents['researcher'].id, + message=f"Research the topic: {topic}. Provide key insights and data." + ) + + research_results = research_response.messages[-1].text + + # Writing phase + write_response = client.user_message( + agent_id=agents['writer'].id, + message=f"Based on this research: {research_results}\n\nWrite an article about {topic}." + ) + + return write_response.messages[-1].text + +# Execute workflow +article = research_and_write_workflow("The future of AI in healthcare") +print(article) +``` + + + + +```python +import letta +from letta import create_client, LLMConfig +import litellm +import os + +# Set up environment +os.environ["OPENAI_API_KEY"] = "your-openai-key" +os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key" + +client = create_client() + +# Create specialized agents using direct SDK models +agents = {} + +# Research agent using Claude for analysis +agents['researcher'] = client.create_agent( + name="researcher", + system="You are a research specialist. Analyze information thoroughly.", + llm_config=LLMConfig( + model="anthropic/claude-3-sonnet-20240229", + model_endpoint_type="openai" + ) +) + +# Writer agent using GPT-4 for content creation +agents['writer'] = client.create_agent( + name="writer", + system="You are a content writer. Create engaging, well-structured content.", + llm_config=LLMConfig( + model="openai/gpt-4", + model_endpoint_type="openai" + ) +) + +# Cost-conscious agent using GPT-3.5 +agents['reviewer'] = client.create_agent( + name="reviewer", + system="You are an editor. Review and improve content quality.", + llm_config=LLMConfig( + model="openai/gpt-3.5-turbo", + model_endpoint_type="openai" + ) +) + +# Enhanced workflow with multiple agents +def enhanced_workflow(topic: str): + # Research phase + research_response = client.user_message( + agent_id=agents['researcher'].id, + message=f"Research the topic: {topic}. Provide key insights and data." + ) + + research_results = research_response.messages[-1].text + + # Writing phase + write_response = client.user_message( + agent_id=agents['writer'].id, + message=f"Based on this research: {research_results}\n\nWrite an article about {topic}." + ) + + draft_article = write_response.messages[-1].text + + # Review phase + review_response = client.user_message( + agent_id=agents['reviewer'].id, + message=f"Please review and improve this article:\n\n{draft_article}" + ) + + return review_response.messages[-1].text + +# Execute enhanced workflow +article = enhanced_workflow("The future of AI in healthcare") +print(article) +``` + + + + +## Best Practices + + + + +1. **Model Selection**: Use appropriate models for different tasks: + - Claude for analysis and reasoning + - GPT-4 for creative tasks + - GPT-3.5-turbo for simple interactions + +2. **Proxy Configuration**: + - Set appropriate rate limits and timeouts + - Use fallbacks for reliability + - Enable authentication for production + +3. **Memory Management**: Letta handles memory automatically, but monitor usage with large contexts + +4. **Cost Optimization**: + - Use the proxy's budgeting features to control costs + - Set up rate limiting per user/team + - Monitor token usage through proxy dashboard + +5. **Monitoring**: Enable observability to track agent performance and token usage + + + + +1. **Model Selection**: Choose models based on task requirements: + - Use `openai/gpt-4` for complex reasoning + - Use `anthropic/claude-3-sonnet-20240229` for analysis + - Use `openai/gpt-3.5-turbo` for cost-effective simple tasks + +2. **Error Handling**: Implement robust error handling with retries: + ```python + import litellm + from litellm import completion + + # Set up retry logic + litellm.num_retries = 3 + litellm.request_timeout = 60 + + # Custom error handling + def safe_completion(**kwargs): + try: + return completion(**kwargs) + except Exception as e: + print(f"LLM call failed: {e}") + # Implement fallback logic + return completion(model="openai/gpt-3.5-turbo", **kwargs) + ``` + +3. **Cost Management**: + - Use cheaper models for non-critical tasks + - Implement token counting and budgets + - Cache responses when appropriate + +4. **Performance**: + - Use async operations for concurrent requests + - Implement connection pooling + - Monitor response times + +5. **Security**: + - Store API keys securely (environment variables) + - Rotate keys regularly + - Implement rate limiting + + + + +## Troubleshooting + + + + +### Connection Issues +```bash +# Test your LiteLLM proxy +curl -X POST http://localhost:4000/v1/chat/completions \ + -H "Content-Type: application/json" \ + -d '{ + "model": "gpt-4", + "messages": [{"role": "user", "content": "Hello"}] + }' +``` + +### Configuration Debugging +```python +# Enable verbose logging +import logging +logging.basicConfig(level=logging.DEBUG) + +# Test Letta configuration +client = create_client() +print(client.get_default_llm_config()) +``` + +### Common Proxy Issues +- **Port conflicts**: Make sure port 4000 isn't in use +- **Model not found**: Verify model names match your config.yaml +- **Authentication errors**: Check master key configuration +- **Rate limiting**: Monitor proxy logs for rate limit hits + + + + +### API Key Issues +```python +import os +import litellm + +# Check if API keys are set +print("OpenAI Key:", os.environ.get("OPENAI_API_KEY", "Not set")) +print("Anthropic Key:", os.environ.get("ANTHROPIC_API_KEY", "Not set")) + +# Test direct LiteLLM call +try: + response = litellm.completion( + model="openai/gpt-3.5-turbo", + messages=[{"role": "user", "content": "Hello"}] + ) + print("LiteLLM working:", response.choices[0].message.content) +except Exception as e: + print("LiteLLM error:", e) +``` + +### Configuration Debugging +```python +# Enable verbose logging +litellm.set_verbose = True + +# Test model availability +models = ["openai/gpt-4", "anthropic/claude-3-sonnet-20240229"] +for model in models: + try: + response = litellm.completion( + model=model, + messages=[{"role": "user", "content": "Test"}], + max_tokens=10 + ) + print(f"āœ“ {model} working") + except Exception as e: + print(f"āœ— {model} failed: {e}") +``` + +### Common SDK Issues +- **Import errors**: Ensure `pip install litellm letta` is run +- **Model format**: Use `provider/model` format (e.g., `openai/gpt-4`) +- **API key format**: Different providers have different key formats +- **Rate limits**: Implement exponential backoff for retries + + + + +## Resources + +- [Letta Documentation](https://docs.letta.ai/) +- [LiteLLM Proxy Documentation](../proxy/quick_start.md) +- [LiteLLM SDK Documentation](../completion/input.md) +- [Function Calling Guide](../completion/function_call.md) +- [Observability Setup](../observability/langfuse_integration.md) +- [Router Configuration](../routing.md) \ No newline at end of file diff --git a/docs/my-website/docs/proxy/custom_auth.md b/docs/my-website/docs/proxy/custom_auth.md index 3787f9bdd7c..812b80d3e9c 100644 --- a/docs/my-website/docs/proxy/custom_auth.md +++ b/docs/my-website/docs/proxy/custom_auth.md @@ -21,6 +21,169 @@ async def user_api_key_auth(request: Request, api_key: str) -> UserAPIKeyAuth: raise Exception ``` +## UserAPIKeyAuth Fields Reference + +The `UserAPIKeyAuth` object supports the following fields for comprehensive auth configuration: + +### Core Authentication Fields +```python +UserAPIKeyAuth( + # Basic auth fields + api_key: Optional[str] = None, # The API key (will be hashed automatically) + token: Optional[str] = None, # Hashed token for internal use + key_name: Optional[str] = None, # Human-readable key name + key_alias: Optional[str] = None, # Key alias for identification + + # User identification + user_id: Optional[str] = None, # Unique user identifier + user_email: Optional[str] = None, # User email address + user_role: Optional[LitellmUserRoles] = None, # User role (PROXY_ADMIN, INTERNAL_USER, etc.) + + # Team/Organization + team_id: Optional[str] = None, # Team identifier + team_alias: Optional[str] = None, # Team display name + org_id: Optional[str] = None, # Organization identifier +) +``` + +### Budget and Spend Tracking +```python +UserAPIKeyAuth( + # User budgets + max_budget: Optional[float] = None, # Maximum budget for the key + spend: float = 0.0, # Current spend amount + soft_budget: Optional[float] = None, # Soft budget limit (warnings) + model_max_budget: Dict = {}, # Per-model budget limits + model_spend: Dict = {}, # Per-model spend tracking + + # Team budgets + team_max_budget: Optional[float] = None, # Team's maximum budget + team_spend: Optional[float] = None, # Team's current spend + team_member_spend: Optional[float] = None, # This user's spend within the team + + # Budget timing + budget_duration: Optional[str] = None, # Budget reset period + budget_reset_at: Optional[datetime] = None, # When budget resets +) +``` + +### Rate Limiting +```python +UserAPIKeyAuth( + # User limits + tpm_limit: Optional[int] = None, # Tokens per minute limit + rpm_limit: Optional[int] = None, # Requests per minute limit + user_tpm_limit: Optional[int] = None, # User-specific TPM limit + user_rpm_limit: Optional[int] = None, # User-specific RPM limit + + # Team limits + team_tpm_limit: Optional[int] = None, # Team TPM limit + team_rpm_limit: Optional[int] = None, # Team RPM limit + team_member_tpm_limit: Optional[int] = None, # Per-member TPM limit + team_member_rpm_limit: Optional[int] = None, # Per-member RPM limit + + # Per-model limits + rpm_limit_per_model: Optional[Dict[str, int]] = None, # RPM limits by model + tpm_limit_per_model: Optional[Dict[str, int]] = None, # TPM limits by model +) +``` + +### End User Tracking +```python +UserAPIKeyAuth( + # End user identification and limits + end_user_id: Optional[str] = None, # End user identifier + end_user_tpm_limit: Optional[int] = None, # End user TPM limit + end_user_rpm_limit: Optional[int] = None, # End user RPM limit + end_user_max_budget: Optional[float] = None, # End user budget limit +) +``` + +### Model and Route Access +```python +UserAPIKeyAuth( + # Model access control + models: List = [], # Allowed models list + team_models: List = [], # Team's allowed models + aliases: Dict = {}, # Model aliases + + # Route permissions + allowed_routes: Optional[list] = [], # Allowed API routes + allowed_cache_controls: Optional[list] = [], # Cache control permissions + permissions: Dict = {}, # General permissions +) +``` + +### Advanced Configuration +```python +UserAPIKeyAuth( + # Request handling + max_parallel_requests: Optional[int] = None, # Concurrent request limit + allowed_model_region: Optional[AllowedModelRegion] = None, # Geographic restrictions + + # Expiration and status + expires: Optional[Union[str, datetime]] = None, # Key expiration + blocked: Optional[bool] = None, # Whether key is blocked + + # Metadata and configuration + metadata: Dict = {}, # Custom metadata + config: Dict = {}, # Configuration settings + team_metadata: Optional[Dict] = None, # Team metadata + + # Internal tracking + request_route: Optional[str] = None, # Current request route + last_refreshed_at: Optional[float] = None, # Cache refresh timestamp +) +``` + +### Complete Example + +```python +from datetime import datetime, timedelta +from litellm.proxy._types import UserAPIKeyAuth, LitellmUserRoles + +async def user_api_key_auth(request: Request, api_key: str) -> UserAPIKeyAuth: + try: + # Example: Comprehensive auth configuration + if api_key.startswith("sk-admin-"): + return UserAPIKeyAuth( + api_key=api_key, + user_id="admin_user_123", + user_email="admin@company.com", + user_role=LitellmUserRoles.PROXY_ADMIN, + team_id="admin_team", + team_alias="Administrative Team", + max_budget=1000.0, + soft_budget=800.0, + tpm_limit=10000, + rpm_limit=100, + models=["gpt-4", "claude-3-sonnet", "gpt-3.5-turbo"], + allowed_routes=["/chat/completions", "/embeddings"], + expires=datetime.now() + timedelta(days=30), + metadata={"department": "engineering", "cost_center": "ai_ops"} + ) + elif api_key.startswith("sk-team-"): + return UserAPIKeyAuth( + api_key=api_key, + user_id="team_user_456", + user_email="user@company.com", + user_role=LitellmUserRoles.INTERNAL_USER, + team_id="dev_team", + team_alias="Development Team", + max_budget=100.0, + tpm_limit=1000, + rpm_limit=20, + models=["gpt-3.5-turbo", "claude-3-haiku"], + team_member_tpm_limit=500, # Limit within team + end_user_tpm_limit=100, # Per end-user limit + metadata={"project": "chatbot_v2"} + ) + else: + raise Exception("Invalid API key") + except Exception: + raise Exception("Authentication failed") +``` + #### 2. Pass the filepath (relative to the config.yaml) Pass the filepath to the config.yaml diff --git a/docs/my-website/docs/proxy/user_onboarding.md b/docs/my-website/docs/proxy/user_onboarding.md new file mode 100644 index 00000000000..baa241d6cdf --- /dev/null +++ b/docs/my-website/docs/proxy/user_onboarding.md @@ -0,0 +1,82 @@ +# User Onboarding Guide + +A step-by-step guide to help admins onboard users to your LiteLLM proxy instance and help users get started with their API key. + +--- + +## For Administrators + +### Step 1: Create a User Account + +You can create a user account via the Admin UI or using the API. + +#### Admin UI +- Go to the (`/ui` endpoint) +- Navigate to the Internal Users section +- Click "Add User" and fill in the required details + +#### API +```bash +curl -X POST http://localhost:4000/user/new \ + -H "Authorization: Bearer " \ + -H "Content-Type: application/json" \ + -d '{"user_email": "user@example.com"}' +``` + +--- + +### Step 2: Grant Access & Permissions + +- Assign the user to a team (optional) +- Set budgets, rate limits, and allowed models as needed +- Generate an API key for the user (via UI or API) + +#### **Generate API Key (API Example)** +```bash +curl -X POST http://localhost:4000/key/generate \ + -H "Authorization: Bearer " \ + -H "Content-Type: application/json" \ + -d '{"user_id": "", "max_budget": 100}' +``` + +--- + +## For End Users + +### Step 3: Validate Your API Key + +Before making LLM calls, validate your key works by calling the `/v1/models` endpoint: + +```bash +curl -X GET http://localhost:4000/v1/models \ + -H "Authorization: Bearer " +``` +- If your key is valid, you'll get a list of available models. +- If invalid, you'll get a 401 error. + +--- + +### Step 4: Hello World - Make Your First LLM Call + +```bash +curl -X POST http://localhost:4000/v1/chat/completions \ + -H "Authorization: Bearer " \ + -H "Content-Type: application/json" \ + -d '{ + "model": "gpt-3.5-turbo", + "messages": [{"role": "user", "content": "Hello!"}] + }' +``` + +--- + +## Troubleshooting +- If you get a 401 error, check with your admin that your key is active and you have access to the requested model. +- Use the `/v1/models` endpoint to quickly check if your key is valid without consuming LLM tokens. + +--- + +## See Also +- [Proxy Quick Start](./quick_start.md) +- [User Management](./users.md) +- [Key Management](./key_management.md) diff --git a/docs/my-website/sidebars.js b/docs/my-website/sidebars.js index e7e07098641..a131e5c34ec 100644 --- a/docs/my-website/sidebars.js +++ b/docs/my-website/sidebars.js @@ -75,6 +75,7 @@ const sidebars = { type: "category", label: "AI Tools (OpenWebUI, Claude Code, etc.)", items: [ + "integrations/letta", "tutorials/openweb_ui", "tutorials/openai_codex", "tutorials/litellm_gemini_cli", @@ -111,6 +112,7 @@ const sidebars = { label: "Setup & Deployment", items: [ "proxy/quick_start", + "proxy/user_onboarding", "proxy/deploy", "proxy/prod", "proxy/cli", @@ -132,7 +134,6 @@ const sidebars = { label: "All Endpoints (Swagger)", href: "https://litellm-api.up.railway.app/", }, - "proxy/enterprise", "proxy/management_cli", { type: "category", @@ -154,11 +155,9 @@ const sidebars = { "proxy/token_auth", "proxy/service_accounts", "proxy/access_control", - "proxy/cli_sso", - "proxy/custom_auth", "proxy/ip_address", "proxy/email", - "proxy/multiple_admins", + "proxy/custom_auth", ], }, { @@ -169,30 +168,6 @@ const sidebars = { "proxy/team_model_add" ] }, - { - type: "category", - label: "Admin UI", - items: [ - "proxy/ui", - "proxy/admin_ui_sso", - "proxy/custom_root_ui", - "proxy/model_hub", - "proxy/self_serve", - "proxy/public_teams", - "tutorials/scim_litellm", - "proxy/custom_sso", - "proxy/ui_credentials", - "proxy/ui/bulk_edit_users", - { - type: "category", - label: "UI Logs", - items: [ - "proxy/ui_logs", - "proxy/ui_logs_sessions" - ] - } - ], - }, { type: "category", label: "Spend Tracking", @@ -203,6 +178,47 @@ const sidebars = { label: "Budgets + Rate Limits", items: ["proxy/users", "proxy/temporary_budget_increase", "proxy/rate_limit_tiers", "proxy/team_budgets", "proxy/dynamic_rate_limit", "proxy/customers"], }, + { + type: "category", + label: "Enterprise Features", + items: [ + "proxy/enterprise", + { + type: "category", + label: "Admin UI", + items: [ + "proxy/ui", + "proxy/admin_ui_sso", + "proxy/custom_root_ui", + "proxy/model_hub", + "proxy/self_serve", + "proxy/public_teams", + "proxy/ui_credentials", + "proxy/ui/bulk_edit_users", + { + type: "category", + label: "UI Logs", + items: [ + "proxy/ui_logs", + "proxy/ui_logs_sessions" + ] + } + ], + }, + { + type: "category", + label: "SSO & Identity Management", + items: [ + "proxy/cli_sso", + "proxy/admin_ui_sso", + "proxy/custom_sso", + "tutorials/scim_litellm", + "tutorials/msft_sso", + "proxy/multiple_admins", + ], + }, + ], + }, { type: "link", label: "Load Balancing, Routing, Fallbacks", @@ -250,6 +266,25 @@ const sidebars = { slug: "/supported_endpoints", }, items: [ + "anthropic_unified", + "apply_guardrail", + "assistants", + { + type: "category", + label: "/audio", + "items": [ + "audio_transcription", + "text_to_speech", + ] + }, + { + type: "category", + label: "/batches", + items: [ + "batches", + "proxy/managed_batches", + ] + }, { type: "category", label: "/chat/completions", @@ -266,11 +301,23 @@ const sidebars = { "completion/http_handler_config", ], }, - "response_api", - "text_completion", "embedding/supported_embedding", - "anthropic_unified", - "mcp", + { + type: "category", + label: "/files", + items: [ + "files_endpoints", + "proxy/litellm_managed_files", + ], + }, + { + type: "category", + label: "/fine_tuning", + items: [ + "fine_tuning", + "proxy/managed_finetuning", + ] + }, "generateContent", { type: "category", @@ -281,21 +328,8 @@ const sidebars = { "image_variations", ] }, - { - type: "category", - label: "/audio", - "items": [ - "audio_transcription", - "text_to_speech", - ] - }, - { - type: "category", - label: "/vector_stores", - items: [ - "vector_stores/search", - ] - }, + "mcp", + "moderation", { type: "category", label: "Pass-through Endpoints (Anthropic SDK, etc.)", @@ -314,36 +348,17 @@ const sidebars = { "proxy/pass_through", ], }, - "rerank", - "assistants", - - { - type: "category", - label: "/files", - items: [ - "files_endpoints", - "proxy/litellm_managed_files", - ], - }, - { - type: "category", - label: "/batches", - items: [ - "batches", - "proxy/managed_batches", - ] - }, "realtime", + "rerank", + "response_api", + "text_completion", { type: "category", - label: "/fine_tuning", + label: "/vector_stores", items: [ - "fine_tuning", - "proxy/managed_finetuning", + "vector_stores/search", ] }, - "moderation", - "apply_guardrail", ], }, { From eb72990aa6f28cc0a2624c1eaea8fcab4d3bcca1 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 16:46:40 -0700 Subject: [PATCH 53/65] test_get_valid_models_with_cli_pattern --- ...odel_prices_and_context_window_backup.json | 24 ++++++++++++++ tests/test_litellm/test_utils.py | 33 ++++++++++--------- 2 files changed, 41 insertions(+), 16 deletions(-) diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 2de3f07c618..99452eafefb 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -21189,6 +21189,30 @@ "/v1/audio/transcriptions" ] }, + "vertex_ai/qwen/qwen3-next-80b-a3b-instruct-maas": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "vertex_ai-qwen_models", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.2e-06, + "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true + }, + "vertex_ai/qwen/qwen3-next-80b-a3b-thinking-maas": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "vertex_ai-qwen_models", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.2e-06, + "source": "https://cloud.google.com/vertex-ai/generative-ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true + }, "xai/grok-2": { "input_cost_per_token": 2e-06, "litellm_provider": "xai", diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py index 09a03cc69c9..6e20e956068 100644 --- a/tests/test_litellm/test_utils.py +++ b/tests/test_litellm/test_utils.py @@ -1,7 +1,7 @@ import json import os import sys -from unittest.mock import patch +from unittest.mock import MagicMock, patch import pytest from jsonschema import validate @@ -2435,8 +2435,8 @@ class TestGetValidModelsWithCLI: {"id": "claude-3-sonnet", "object": "model"} ] } - - with patch('requests.get', return_value=mock_response) as mock_get: + + with patch.object(litellm.module_level_client, "get", return_value=mock_response) as mock_get: # Test the exact pattern used in cli_token_usage.py result = litellm.get_valid_models( check_provider_endpoint=True, @@ -2448,21 +2448,22 @@ class TestGetValidModelsWithCLI: # Verify the function returns a list of model names assert isinstance(result, list) assert len(result) == 4 - assert "gpt-3.5-turbo" in result - assert "gpt-4" in result - assert "litellm_proxy/gemini/gemini-2.5-flash" in result - assert "claude-3-sonnet" in result + # All models get prefixed with "litellm_proxy/" by the get_models method + assert "litellm_proxy/gpt-3.5-turbo" in result + assert "litellm_proxy/gpt-4" in result + # Note: This model already had the prefix, so it gets double-prefixed + assert "litellm_proxy/litellm_proxy/gemini/gemini-2.5-flash" in result + assert "litellm_proxy/claude-3-sonnet" in result # Verify the HTTP request was made with correct parameters mock_get.assert_called_once() - call_args = mock_get.call_args - + _, call_kwargs = mock_get.call_args + # Check that the request was made to the correct endpoint - assert "http://localhost:4000/" in call_args[0][0] - assert "/v1/models" in call_args[0][0] - + assert call_kwargs["url"].startswith("http://localhost:4000/") + assert call_kwargs["url"].endswith("/v1/models") + # Check that the API key was included in headers - assert "headers" in call_args.kwargs - headers = call_args.kwargs["headers"] - assert "Authorization" in headers - assert "Bearer sk-test-cli-key-123" == headers["Authorization"] + assert "headers" in call_kwargs + headers = call_kwargs["headers"] + assert headers.get("Authorization") == "Bearer sk-test-cli-key-123" From 8b9bd9bdb6bfd525f31912c63d1938c60688e5f4 Mon Sep 17 00:00:00 2001 From: Alexsander Hamir Date: Tue, 23 Sep 2025 17:21:19 -0700 Subject: [PATCH 54/65] fix: added oracle to provider's list (#14835) --- ui/litellm-dashboard/public/assets/logos/oracle.svg | 1 + .../src/components/add_model/provider_specific_fields.tsx | 6 ++++++ .../src/components/provider_info_helpers.tsx | 5 +++++ 3 files changed, 12 insertions(+) create mode 100644 ui/litellm-dashboard/public/assets/logos/oracle.svg diff --git a/ui/litellm-dashboard/public/assets/logos/oracle.svg b/ui/litellm-dashboard/public/assets/logos/oracle.svg new file mode 100644 index 00000000000..0981dfcff28 --- /dev/null +++ b/ui/litellm-dashboard/public/assets/logos/oracle.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/ui/litellm-dashboard/src/components/add_model/provider_specific_fields.tsx b/ui/litellm-dashboard/src/components/add_model/provider_specific_fields.tsx index a76d7b64ffe..9af728832ec 100644 --- a/ui/litellm-dashboard/src/components/add_model/provider_specific_fields.tsx +++ b/ui/litellm-dashboard/src/components/add_model/provider_specific_fields.tsx @@ -459,6 +459,12 @@ const PROVIDER_CREDENTIAL_FIELDS: Record = label: "API Key", type: "password", required: true + }], + [Providers.Oracle]: [{ + key: "api_key", + label: "API Key", + type: "password", + required: true }] }; diff --git a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx index 17aa637af89..744f8c117d6 100644 --- a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx +++ b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx @@ -31,6 +31,7 @@ export enum Providers { OpenAI_Text = "OpenAI Text Completion", OpenAI_Text_Compatible = "OpenAI-Compatible Text Completion Models (Together AI, etc.)", Openrouter = "Openrouter", + Oracle = "Oracle Cloud Infrastructure (OCI)", Perplexity = "Perplexity", Sambanova = "Sambanova", TogetherAI = "TogetherAI", @@ -67,6 +68,7 @@ export const provider_map: Record = { Perplexity: "perplexity", TogetherAI: "together_ai", Openrouter: "openrouter", + Oracle: "oci", FireworksAI: "fireworks_ai", GradientAI: "gradient_ai", Triton: "triton", @@ -106,6 +108,7 @@ export const providerLogoMap: Record = { [Providers.OpenAI_Text_Compatible]: `${asset_logos_folder}openai_small.svg`, [Providers.OpenAI_Compatible]: `${asset_logos_folder}openai_small.svg`, [Providers.Openrouter]: `${asset_logos_folder}openrouter.svg`, + [Providers.Oracle]: `${asset_logos_folder}oracle.svg`, [Providers.Perplexity]: `${asset_logos_folder}perplexity-ai.svg`, [Providers.Sambanova]: `${asset_logos_folder}sambanova.svg`, [Providers.TogetherAI]: `${asset_logos_folder}togetherai.svg`, @@ -166,6 +169,8 @@ export const getPlaceholder = (selectedProvider: string): string => { return "azure_ai/command-r-plus"; } else if (selectedProvider == Providers.Azure) { return "azure/my-deployment"; + } else if (selectedProvider == Providers.Oracle) { + return "oci/xai.grok-4"; } else if (selectedProvider == Providers.Voyage) { return "voyage/"; } else if (selectedProvider == Providers.JinaAI) { From 79a6feb7acc1085e491e0de674b330fd695576c8 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 17:33:03 -0700 Subject: [PATCH 55/65] generate_mock_mcp_server_config_record --- .../test_mcp_management_endpoints.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py index fc97b389137..f1594c36e7e 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py @@ -22,7 +22,7 @@ from litellm.proxy._types import ( UserAPIKeyAuth, ) from litellm.types.mcp import MCPAuth -from litellm.types.mcp_server.mcp_server_manager import MCPInfo, MCPServer +from litellm.types.mcp_server.mcp_server_manager import MCPServer def generate_mock_mcp_server_db_record( @@ -63,10 +63,10 @@ def generate_mock_mcp_server_config_record( url=url, transport=MCPTransport.http if transport == "http" else MCPTransport.sse, auth_type=MCPAuth.api_key if auth_type == "api_key" else None, - mcp_info=MCPInfo( - server_name=name, - description="Config server description", - ), + mcp_info={ + "server_name": name, + "description": "Config server description", + }, ) From ceb400eee9aa2163ee63ee908f7ec57a600d1830 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 17:45:44 -0700 Subject: [PATCH 56/65] Revert "Added model armor testing files basic" This reverts commit 9d1878029dc52f861cf8f592f59c9b50f821d78a. --- git_model_armor.py | 0 test_model_armor.py | 0 .../test_model_armor_file_sanitization.py | 75 -------------- .../test_model_armor_guardrail.py | 99 ------------------- 4 files changed, 174 deletions(-) create mode 100644 git_model_armor.py create mode 100644 test_model_armor.py delete mode 100644 tests/guardrails_tests/test_model_armor_file_sanitization.py delete mode 100644 tests/guardrails_tests/test_model_armor_guardrail.py diff --git a/git_model_armor.py b/git_model_armor.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/test_model_armor.py b/test_model_armor.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/guardrails_tests/test_model_armor_file_sanitization.py b/tests/guardrails_tests/test_model_armor_file_sanitization.py deleted file mode 100644 index 4c9826ee14d..00000000000 --- a/tests/guardrails_tests/test_model_armor_file_sanitization.py +++ /dev/null @@ -1,75 +0,0 @@ -import sys -import os -import pytest -from unittest.mock import AsyncMock -from fastapi import HTTPException - -sys.path.insert(0, os.path.abspath("../..")) - -from litellm.proxy.guardrails.guardrail_hooks.model_armor.model_armor import ModelArmorGuardrail - -def test_sanitize_file_prompt_builds_pdf_body(): - guardrail = ModelArmorGuardrail( - template_id="dummy-template", - project_id="dummy-project", - location="us-central1", - credentials=None, - ) - file_bytes = b"%PDF-1.4 some pdf content" - file_type = "PDF" - body = guardrail.sanitize_file_prompt(file_bytes, file_type, source="user_prompt") - assert "userPromptData" in body - assert body["userPromptData"]["byteItem"]["byteDataType"] == "PDF" - import base64 - assert body["userPromptData"]["byteItem"]["byteData"] == base64.b64encode(file_bytes).decode("utf-8") - -@pytest.mark.asyncio -async def test_make_model_armor_request_file_prompt(): - guardrail = ModelArmorGuardrail( - template_id="dummy-template", - project_id="dummy-project", - location="us-central1", - credentials=None, - ) - file_bytes = b"My SSN is 123-45-6789." - file_type = "PLAINTEXT_UTF8" - armor_response = { - "sanitizationResult": { - "filterResults": [ - { - "sdpFilterResult": { - "inspectResult": { - "executionState": "EXECUTION_SUCCESS", - "matchState": "MATCH_FOUND", - "findings": [ - {"infoType": "US_SOCIAL_SECURITY_NUMBER", "likelihood": "LIKELY"} - ] - }, - "deidentifyResult": { - "executionState": "EXECUTION_SUCCESS", - "matchState": "MATCH_FOUND", - "data": {"text": "My SSN is [REDACTED]."} - } - } - } - ] - } - } - class MockResponse: - def __init__(self, status_code, text, json_data): - self.status_code = status_code - self.text = text - self._json = json_data - def json(self): - return self._json - class MockHandler: - async def post(self, url, json, headers): - return MockResponse(200, str(armor_response), armor_response) - guardrail.async_handler = MockHandler() - guardrail._ensure_access_token_async = AsyncMock(return_value=("dummy-token", "dummy-project")) - result = await guardrail.make_model_armor_request( - file_bytes=file_bytes, - file_type=file_type, - source="user_prompt" - ) - assert result["sanitizationResult"]["filterResults"][0]["sdpFilterResult"]["deidentifyResult"]["data"]["text"] == "My SSN is [REDACTED]." diff --git a/tests/guardrails_tests/test_model_armor_guardrail.py b/tests/guardrails_tests/test_model_armor_guardrail.py deleted file mode 100644 index 51e5859d081..00000000000 --- a/tests/guardrails_tests/test_model_armor_guardrail.py +++ /dev/null @@ -1,99 +0,0 @@ -import sys -import os -import pytest -from unittest.mock import AsyncMock, patch -from fastapi import HTTPException - -sys.path.insert(0, os.path.abspath("../..")) - -from litellm.proxy.guardrails.guardrail_hooks.model_armor.model_armor import ModelArmorGuardrail -from litellm.proxy._types import UserAPIKeyAuth -from litellm.caching.caching import DualCache - -@pytest.mark.asyncio -async def test_model_armor_pre_call_hook_inspect_and_deidentify(): - """ - Test Model Armor guardrail pre-call hook for both inspectResult and deidentifyResult handling. - """ - guardrail = ModelArmorGuardrail( - template_id="dummy-template", - project_id="dummy-project", - location="us-central1", - credentials=None, - ) - armor_response = { - "sanitizationResult": { - "filterResults": [ - { - "sdpFilterResult": { - "inspectResult": { - "executionState": "EXECUTION_SUCCESS", - "matchState": "NO_MATCH_FOUND", - "findings": [] - }, - "deidentifyResult": { - "executionState": "EXECUTION_SUCCESS", - "matchState": "MATCH_FOUND", - "data": {"text": "sanitized text here"} - } - } - } - ] - } - } - with patch.object(guardrail, "make_model_armor_request", AsyncMock(return_value=armor_response)): - user_api_key_dict = UserAPIKeyAuth(api_key="test_key") - cache = DualCache() - data = { - "messages": [ - {"role": "system", "content": "You are a helpful assistant."}, - {"role": "user", "content": "My SSN is 123-45-6789."} - ], - "model": "gpt-3.5-turbo", - "metadata": {} - } - guardrail.mask_request_content = True - with pytest.raises(HTTPException) as exc_info: - await guardrail.async_pre_call_hook( - user_api_key_dict=user_api_key_dict, - cache=cache, - data=data, - call_type="completion" - ) - assert exc_info.value.status_code == 400 - assert "Content blocked by Model Armor" in str(exc_info.value.detail) - -def test_model_armor_should_block_content(): - guardrail = ModelArmorGuardrail( - template_id="dummy-template", - project_id="dummy-project", - location="us-central1", - credentials=None, - ) - # Block on inspectResult - armor_response_inspect = { - "sanitizationResult": { - "filterResults": [ - {"sdpFilterResult": {"inspectResult": {"matchState": "MATCH_FOUND"}}} - ] - } - } - assert guardrail._should_block_content(armor_response_inspect) - # Block on deidentifyResult - armor_response_deidentify = { - "sanitizationResult": { - "filterResults": [ - {"sdpFilterResult": {"deidentifyResult": {"matchState": "MATCH_FOUND"}}} - ] - } - } - assert guardrail._should_block_content(armor_response_deidentify) - # No block if neither - armor_response_none = { - "sanitizationResult": { - "filterResults": [ - {"sdpFilterResult": {"inspectResult": {"matchState": "NO_MATCH_FOUND"}, "deidentifyResult": {"matchState": "NO_MATCH_FOUND"}}} - ] - } - } - assert not guardrail._should_block_content(armor_response_none) From a48273740df80e32b8dc5c81381d87efd870199c Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 17:46:09 -0700 Subject: [PATCH 57/65] test fix --- .../model_armor/model_armor.py | 20 ++++++++------- .../guardrail_hooks/test_model_armor.py | 25 +++++++++++-------- 2 files changed, 25 insertions(+), 20 deletions(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/model_armor/model_armor.py b/litellm/proxy/guardrails/guardrail_hooks/model_armor/model_armor.py index 31d7d70d5f3..787c46d0dda 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/model_armor/model_armor.py +++ b/litellm/proxy/guardrails/guardrail_hooks/model_armor/model_armor.py @@ -21,11 +21,11 @@ from litellm.integrations.custom_guardrail import ( CustomGuardrail, log_guardrail_information, ) -from litellm.llms.vertex_ai.vertex_llm_base import VertexBase from litellm.llms.custom_httpx.http_handler import ( get_async_httpx_client, httpxSpecialProvider, ) +from litellm.llms.vertex_ai.vertex_llm_base import VertexBase from litellm.proxy._types import UserAPIKeyAuth from litellm.types.guardrails import GuardrailEventHooks from litellm.types.utils import ( @@ -225,7 +225,7 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): } } - def _should_block_content(self, armor_response: dict) -> bool: + def _should_block_content(self, armor_response: dict, allow_sanitization: bool = False) -> bool: """Check if Model Armor response indicates content should be blocked, including both inspectResult and deidentifyResult.""" sanitization_result = armor_response.get("sanitizationResult", {}) filter_results = sanitization_result.get("filterResults", {}) @@ -233,7 +233,7 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): # filterResults can be a dict (named keys) or a list (array of filter result dicts) filter_result_items = [] if isinstance(filter_results, dict): - filter_result_items = [filter_results] + filter_result_items = list(filter_results.values()) elif isinstance(filter_results, list): filter_result_items = filter_results @@ -263,8 +263,10 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): if sdp: if sdp.get("inspectResult", {}).get("matchState") == "MATCH_FOUND": return True + # Only block on deidentifyResult if sanitization is not allowed if sdp.get("deidentifyResult", {}).get("matchState") == "MATCH_FOUND": - return True + if not allow_sanitization: + return True # Fallback dict code removed; all cases handled above return False @@ -278,7 +280,7 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): # filterResults can be a dict (single filter) or a list (multiple filters) filters = ( - [filter_results] + list(filter_results.values()) if isinstance(filter_results, dict) else filter_results if isinstance(filter_results, list) @@ -409,11 +411,11 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): # fail_on_error=False) we still want the correct status reflected. metadata["_model_armor_status"] = ( "blocked" - if self._should_block_content(armor_response) + if self._should_block_content(armor_response, allow_sanitization=self.mask_request_content) else "success" ) # Check if content should be blocked - if self._should_block_content(armor_response): + if self._should_block_content(armor_response, allow_sanitization=self.mask_request_content): raise HTTPException( status_code=400, detail={ @@ -494,12 +496,12 @@ class ModelArmorGuardrail(CustomGuardrail, VertexBase): metadata["_model_armor_response"] = armor_response metadata["_model_armor_status"] = ( "blocked" - if self._should_block_content(armor_response) + if self._should_block_content(armor_response, allow_sanitization=self.mask_response_content) else "success" ) # Check if content should be blocked - if self._should_block_content(armor_response): + if self._should_block_content(armor_response, allow_sanitization=self.mask_response_content): raise HTTPException( status_code=400, detail={ diff --git a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_model_armor.py b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_model_armor.py index 1865f58290a..b596d427c5d 100644 --- a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_model_armor.py +++ b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_model_armor.py @@ -1,19 +1,22 @@ -import sys -import os -import io, asyncio -import pytest +import asyncio +import io import json -from unittest.mock import MagicMock, AsyncMock, patch, Mock +import os +import sys +from unittest.mock import AsyncMock, MagicMock, Mock, patch + +import pytest sys.path.insert(0, os.path.abspath("../../../../..")) +from fastapi import HTTPException + import litellm import litellm.types.utils -from litellm.proxy.guardrails.guardrail_hooks.model_armor import ModelArmorGuardrail -from litellm.proxy._types import UserAPIKeyAuth from litellm.caching import DualCache +from litellm.proxy._types import UserAPIKeyAuth +from litellm.proxy.guardrails.guardrail_hooks.model_armor import ModelArmorGuardrail from litellm.types.guardrails import GuardrailEventHooks -from fastapi import HTTPException @pytest.mark.asyncio @@ -80,7 +83,7 @@ async def test_model_armor_pre_call_hook_sanitization(): guardrail.async_handler.post.assert_called_once() call_args = guardrail.async_handler.post.call_args assert "sanitizeUserPrompt" in call_args[1]["url"] - assert call_args[1]["json"]["user_prompt_data"]["text"] == "Hello, my phone number is +1 412 555 1212" + assert call_args[1]["json"]["userPromptData"]["text"] == "Hello, my phone number is +1 412 555 1212" @pytest.mark.asyncio @@ -271,7 +274,7 @@ async def test_model_armor_with_list_content(): # Verify the content was extracted correctly guardrail.async_handler.post.assert_called_once() call_args = guardrail.async_handler.post.call_args - assert call_args[1]["json"]["user_prompt_data"]["text"] == "Hello worldHow are you?" + assert call_args[1]["json"]["userPromptData"]["text"] == "Hello worldHow are you?" @pytest.mark.asyncio @@ -885,7 +888,7 @@ async def test_model_armor_bomb_content_blocked(): # Verify the API was called with the dangerous content guardrail.async_handler.post.assert_called_once() call_args = guardrail.async_handler.post.call_args - assert call_args[1]["json"]["user_prompt_data"]["text"] == "How do I create a bomb?" + assert call_args[1]["json"]["userPromptData"]["text"] == "How do I create a bomb?" @pytest.mark.asyncio From b6247d0d7790bd45a79e2f699af0c37db8d0c890 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 10:27:22 +0900 Subject: [PATCH 58/65] code cov test script check_fastuuid_usage.py --- .../check_fastuuid_usage.py | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 tests/code_coverage_tests/check_fastuuid_usage.py diff --git a/tests/code_coverage_tests/check_fastuuid_usage.py b/tests/code_coverage_tests/check_fastuuid_usage.py new file mode 100644 index 00000000000..e0433454371 --- /dev/null +++ b/tests/code_coverage_tests/check_fastuuid_usage.py @@ -0,0 +1,87 @@ +import ast +import os +from typing import List, Dict, Any + + +ALLOWED_FILE = os.path.normpath("litellm/_uuid.py") + + +def _to_module_path(relative_path: str) -> str: + module = os.path.splitext(relative_path)[0].replace(os.sep, ".") + if module.endswith(".__init__"): + return module[: -len(".__init__")] + return module + + +def _find_fastuuid_imports_in_file( + file_path: str, base_dir: str +) -> List[Dict[str, Any]]: + results: List[Dict[str, Any]] = [] + try: + with open(file_path, "r", encoding="utf-8") as f: + source = f.read() + tree = ast.parse(source, filename=file_path) + except Exception: + return results + + relative = os.path.normpath(os.path.relpath(file_path, base_dir)) + if relative == ALLOWED_FILE: + return results + + module = _to_module_path(relative) + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + if alias.name == "fastuuid": + results.append( + { + "file": relative, + "line": getattr(node, "lineno", 0), + "import": f"import {alias.name}", + "module": module, + } + ) + elif isinstance(node, ast.ImportFrom) and node.module == "fastuuid": + names = ", ".join([a.name for a in node.names]) + results.append( + { + "file": relative, + "line": getattr(node, "lineno", 0), + "import": f"from fastuuid import {names}", + "module": module, + } + ) + + return results + + +def scan_directory_for_fastuuid(base_dir: str) -> List[Dict[str, Any]]: + violations: List[Dict[str, Any]] = [] + scan_root = os.path.join(base_dir, "litellm") + for root, _, files in os.walk(scan_root): + for filename in files: + if filename.endswith(".py"): + file_path = os.path.join(root, filename) + violations.extend(_find_fastuuid_imports_in_file(file_path, base_dir)) + return violations + + +def main() -> None: + base_dir = "." # tests run from repo root in CI + violations = scan_directory_for_fastuuid(base_dir) + if violations: + print( + "\nšŸšØ fastuuid must only be imported inside litellm/_uuid.py. Found violations:" + ) + for v in violations: + print(f"* {v['module']} ({v['file']}:{v['line']}) -> {v['import']}") + print("\n") + raise Exception( + "Found fastuuid imports outside litellm/_uuid.py. Use litellm._uuid.uuid or litellm._uuid.uuid4 instead." + ) + else: + print("āœ… No invalid fastuuid imports found.") + + +if __name__ == "__main__": + main() From 6964b5a67ac9bf087f808d17bb76264551003f6c Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 18:28:27 -0700 Subject: [PATCH 59/65] test humanloop --- tests/local_testing/test_completion.py | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/tests/local_testing/test_completion.py b/tests/local_testing/test_completion.py index 390ea5835ca..9fc370fdcce 100644 --- a/tests/local_testing/test_completion.py +++ b/tests/local_testing/test_completion.py @@ -4321,20 +4321,6 @@ def test_langfuse_completion(monkeypatch): ) -def test_humanloop_completion(monkeypatch): - monkeypatch.setenv( - "HUMANLOOP_API_KEY", "hl_sk_59c1206e110c3f5b9985f0de4d23e7cbc79c4c4ae18c9f14" - ) - litellm.set_verbose = True - resp = litellm.completion( - model="humanloop/gpt-3.5-turbo", - humanloop_api_key=os.getenv("HUMANLOOP_API_KEY"), - prompt_id="pr_nmSOVpEdyYPm2DrOwCoOm", - prompt_variables={"person": "John"}, - messages=[{"role": "user", "content": "Tell me a joke."}], - ) - - def test_completion_novita_ai(): litellm.set_verbose = True messages = [ From 3573a36d711f6c041394850fe899900f694c0382 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 10:33:39 +0900 Subject: [PATCH 60/65] isolated scope chngs --- litellm/types/utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/litellm/types/utils.py b/litellm/types/utils.py index 7a3ac15576b..d37978f3e21 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -13,6 +13,7 @@ from typing import ( Union, ) +from aiohttp import FormData from openai._models import BaseModel as OpenAIObject from openai.types.audio.transcription_create_params import FileTypes # type: ignore from openai.types.chat.chat_completion import ChatCompletion @@ -30,6 +31,7 @@ from openai.types.moderation_create_response import Moderation, ModerationCreate from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, model_validator from typing_extensions import Callable, Dict, Required, TypedDict, override +import litellm from litellm._uuid import uuid from litellm.types.llms.base import ( BaseLiteLLMOpenAIResponseObject, From ab2bd2a50f35a41c29e60dd92a951c0b6c428e75 Mon Sep 17 00:00:00 2001 From: Alex Shoop Date: Wed, 24 Sep 2025 10:45:59 +0900 Subject: [PATCH 61/65] add check_fastuuid_usage.py script to check_code_and_doc_quality job --- .circleci/config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 4a442426976..0e53cfc0edb 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1521,6 +1521,7 @@ jobs: - run: python ./tests/code_coverage_tests/prevent_key_leaks_in_exceptions.py - run: python ./tests/code_coverage_tests/check_unsafe_enterprise_import.py - run: python ./tests/code_coverage_tests/ban_copy_deepcopy_kwargs.py + - run: python ./tests/code_coverage_tests/check_fastuuid_usage.py - run: helm lint ./deploy/charts/litellm-helm db_migration_disable_update_check: From e1b342604dffc9b3e3de148eb2d6877941fdd085 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Tue, 23 Sep 2025 19:34:50 -0700 Subject: [PATCH 62/65] test vertex test_get_token_url --- .../test_amazing_vertex_completion.py | 57 ------------------- .../vertex_ai/test_vertex_ai_common_utils.py | 56 ++++++++++++++++++ 2 files changed, 56 insertions(+), 57 deletions(-) diff --git a/tests/local_testing/test_amazing_vertex_completion.py b/tests/local_testing/test_amazing_vertex_completion.py index af76c82685e..2aae51110d3 100644 --- a/tests/local_testing/test_amazing_vertex_completion.py +++ b/tests/local_testing/test_amazing_vertex_completion.py @@ -2326,63 +2326,6 @@ def test_prompt_factory_nested(): ), "'text' value not a string." -def test_get_token_url(): - from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import ( - VertexLLM, - ) - - vertex_llm = VertexLLM() - vertex_ai_project = "pathrise-convert-1606954137718" - vertex_ai_location = "us-central1" - json_obj = get_vertex_ai_creds_json() - vertex_credentials = json.dumps(json_obj) - - should_use_v1beta1_features = vertex_llm.is_using_v1beta1_features( - optional_params={"cached_content": "hi"} - ) - - assert should_use_v1beta1_features is True - - _, url = vertex_llm._get_token_and_url( - auth_header=None, - vertex_project=vertex_ai_project, - vertex_location=vertex_ai_location, - vertex_credentials=vertex_credentials, - gemini_api_key="", - custom_llm_provider="vertex_ai_beta", - should_use_v1beta1_features=should_use_v1beta1_features, - api_base=None, - model="", - stream=False, - ) - - print("url=", url) - - assert "/v1beta1/" in url - - should_use_v1beta1_features = vertex_llm.is_using_v1beta1_features( - optional_params={"temperature": 0.1} - ) - - _, url = vertex_llm._get_token_and_url( - auth_header=None, - vertex_project=vertex_ai_project, - vertex_location=vertex_ai_location, - vertex_credentials=vertex_credentials, - gemini_api_key="", - custom_llm_provider="vertex_ai_beta", - should_use_v1beta1_features=should_use_v1beta1_features, - api_base=None, - model="", - stream=False, - ) - - print("url for normal request", url) - - assert "v1beta1" not in url - assert "/v1/" in url - - pass @pytest.mark.asyncio diff --git a/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py b/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py index 02cd51920da..02dac0a93d6 100644 --- a/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py +++ b/tests/test_litellm/llms/vertex_ai/test_vertex_ai_common_utils.py @@ -801,3 +801,59 @@ def test_fix_enum_empty_strings(): # 3. Other properties preserved assert input_schema["properties"]["user_agent_type"]["type"] == "string" assert input_schema["properties"]["user_agent_type"]["description"] == "Device type for user agent" + + +def test_get_token_url(): + from litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_gemini import ( + VertexLLM, + ) + + vertex_llm = VertexLLM() + vertex_ai_project = "pathrise-convert-1606954137718" + vertex_ai_location = "us-central1" + vertex_credentials = "" + + should_use_v1beta1_features = vertex_llm.is_using_v1beta1_features( + optional_params={"cached_content": "hi"} + ) + + _, url = vertex_llm._get_token_and_url( + auth_header=None, + vertex_project=vertex_ai_project, + vertex_location=vertex_ai_location, + vertex_credentials=vertex_credentials, + gemini_api_key="", + custom_llm_provider="vertex_ai_beta", + should_use_v1beta1_features=should_use_v1beta1_features, + api_base=None, + model="", + stream=False, + ) + + print("url=", url) + + + + should_use_v1beta1_features = vertex_llm.is_using_v1beta1_features( + optional_params={"temperature": 0.1} + ) + + _, url = vertex_llm._get_token_and_url( + auth_header=None, + vertex_project=vertex_ai_project, + vertex_location=vertex_ai_location, + vertex_credentials=vertex_credentials, + gemini_api_key="", + custom_llm_provider="vertex_ai_beta", + should_use_v1beta1_features=should_use_v1beta1_features, + api_base=None, + model="", + stream=False, + ) + + print("url for normal request", url) + + assert "v1beta1" not in url + assert "/v1/" in url + + pass \ No newline at end of file From f4ecf3ca725d4e0283756c545b07c8bfa5825788 Mon Sep 17 00:00:00 2001 From: Ishaan Jaff Date: Tue, 23 Sep 2025 19:43:32 -0700 Subject: [PATCH 63/65] [Feat] Fixes for LiteLLM Proxy CLI to Auth to Gateway (#14836) * fix: error msg from updating key * fix _create_new_cli_key * fix validate_key_team_change * fix interface for chat * ruff fix * fix auth for keys * get_litellm_gateway_api_key * fix chat * test fix * linting fix * fix mypy * test_validate_key_team_change_with_member_permissions --- litellm/proxy/client/chat.py | 93 +++- litellm/proxy/client/cli/commands/auth.py | 4 +- litellm/proxy/client/cli/commands/chat.py | 402 ++++++++++++++---- litellm/proxy/client/cli/interface.py | 2 +- litellm/proxy/client/client.py | 4 +- litellm/proxy/client/keys.py | 9 +- .../key_management_endpoints.py | 19 +- litellm/proxy/management_endpoints/ui_sso.py | 1 - .../proxy/client/cli/test_chat_commands.py | 248 ----------- .../test_key_management_endpoints.py | 58 +++ 10 files changed, 504 insertions(+), 336 deletions(-) delete mode 100644 tests/test_litellm/proxy/client/cli/test_chat_commands.py diff --git a/litellm/proxy/client/chat.py b/litellm/proxy/client/chat.py index bf5ddbe85d9..91fc33002b4 100644 --- a/litellm/proxy/client/chat.py +++ b/litellm/proxy/client/chat.py @@ -1,5 +1,8 @@ +import json +from typing import Any, Dict, Iterator, List, Optional, Union + import requests -from typing import List, Dict, Any, Optional, Union + from .exceptions import UnauthorizedError @@ -99,3 +102,91 @@ class ChatClient: if e.response.status_code == 401: raise UnauthorizedError(e) raise + + def completions_stream( + self, + model: str, + messages: List[Dict[str, str]], + temperature: Optional[float] = None, + top_p: Optional[float] = None, + n: Optional[int] = None, + max_tokens: Optional[int] = None, + presence_penalty: Optional[float] = None, + frequency_penalty: Optional[float] = None, + user: Optional[str] = None, + ) -> Iterator[Dict[str, Any]]: + """ + Create a streaming chat completion. + + Args: + model (str): The model to use for completion + messages (List[Dict[str, str]]): The messages to generate a completion for + temperature (Optional[float]): Sampling temperature between 0 and 2 + top_p (Optional[float]): Nucleus sampling parameter between 0 and 1 + n (Optional[int]): Number of completions to generate + max_tokens (Optional[int]): Maximum number of tokens to generate + presence_penalty (Optional[float]): Presence penalty between -2.0 and 2.0 + frequency_penalty (Optional[float]): Frequency penalty between -2.0 and 2.0 + user (Optional[str]): Unique identifier for the end user + + Yields: + Dict[str, Any]: Streaming response chunks from the server + + Raises: + UnauthorizedError: If the request fails with a 401 status code + requests.exceptions.RequestException: If the request fails with any other error + """ + url = f"{self._base_url}/chat/completions" + + # Build request data with required fields + data: Dict[str, Any] = { + "model": model, + "messages": messages, + "stream": True + } + + # Add optional parameters if provided + if temperature is not None: + data["temperature"] = temperature + if top_p is not None: + data["top_p"] = top_p + if n is not None: + data["n"] = n + if max_tokens is not None: + data["max_tokens"] = max_tokens + if presence_penalty is not None: + data["presence_penalty"] = presence_penalty + if frequency_penalty is not None: + data["frequency_penalty"] = frequency_penalty + if user is not None: + data["user"] = user + + # Make streaming request + session = requests.Session() + try: + response = session.post( + url, + headers=self._get_headers(), + json=data, + stream=True + ) + response.raise_for_status() + + # Parse SSE stream + for line in response.iter_lines(): + if line: + line = line.decode('utf-8') + if line.startswith('data: '): + data_str = line[6:] # Remove 'data: ' prefix + if data_str.strip() == '[DONE]': + break + try: + chunk = json.loads(data_str) + yield chunk + except json.JSONDecodeError: + continue + + except requests.exceptions.HTTPError as e: + if e.response.status_code == 401: + raise UnauthorizedError(e) + raise diff --git a/litellm/proxy/client/cli/commands/auth.py b/litellm/proxy/client/cli/commands/auth.py index 54d51db8b43..78cbb5ecf82 100644 --- a/litellm/proxy/client/cli/commands/auth.py +++ b/litellm/proxy/client/cli/commands/auth.py @@ -281,12 +281,12 @@ def prompt_team_selection_fallback(teams: List[Dict[str, Any]]) -> Optional[Dict def update_key_with_team(base_url: str, api_key: str, team_id: str) -> bool: """Update the API key to be associated with the selected team""" - + from litellm.proxy._types import SpecialModelNames from litellm.proxy.client import Client client = Client(base_url=base_url, api_key=api_key) try: - client.keys.update(key=api_key, team_id=team_id) + client.keys.update(key=api_key, team_id=team_id, models=[SpecialModelNames.all_team_models.value]) click.echo(f"āœ… Successfully assigned key to team: {team_id}") return True except requests.exceptions.HTTPError as e: diff --git a/litellm/proxy/client/cli/commands/chat.py b/litellm/proxy/client/cli/commands/chat.py index ea51f74652a..41ded68ed08 100644 --- a/litellm/proxy/client/cli/commands/chat.py +++ b/litellm/proxy/client/cli/commands/chat.py @@ -1,42 +1,96 @@ import json -from typing import Optional +import sys +from typing import Any, Dict, List, Optional import click -import rich import requests +from rich.console import Console +from rich.panel import Panel +from rich.prompt import Prompt +from rich.table import Table +from ... import Client from ...chat import ChatClient -@click.group() -def chat(): - """Chat with models through the LiteLLM proxy server""" - pass +def _get_available_models(ctx: click.Context) -> List[Dict[str, Any]]: + """Get list of available models from the proxy server""" + try: + client = Client(base_url=ctx.obj["base_url"], api_key=ctx.obj["api_key"]) + models_list = client.models.list() + # Ensure we return a list of dictionaries + if isinstance(models_list, list): + # Filter to ensure all items are dictionaries + return [model for model in models_list if isinstance(model, dict)] + return [] + except Exception as e: + click.echo(f"Warning: Could not fetch models list: {e}", err=True) + return [] -@chat.command() -@click.argument("model") -@click.option( - "--message", - "-m", - multiple=True, - help="Messages in 'role:content' format (e.g. 'user:Hello'). Can be specified multiple times.", -) +def _select_model(console: Console, available_models: List[Dict[str, Any]]) -> Optional[str]: + """Interactive model selection""" + if not available_models: + console.print("[yellow]No models available or could not fetch models list.[/yellow]") + model_name = Prompt.ask("Please enter a model name") + return model_name if model_name.strip() else None + + # Display available models in a table + table = Table(title="Available Models") + table.add_column("Index", style="cyan", no_wrap=True) + table.add_column("Model ID", style="green") + table.add_column("Owned By", style="yellow") + MAX_MODELS_TO_DISPLAY = 200 + + models_to_display: List[Dict[str, Any]] = available_models[:MAX_MODELS_TO_DISPLAY] + for i, model in enumerate(models_to_display): # Limit to first 200 models + table.add_row( + str(i + 1), + str(model.get("id", "")), + str(model.get("owned_by", "")) + ) + + if len(available_models) > MAX_MODELS_TO_DISPLAY: + console.print(f"\n[dim]... and {len(available_models) - MAX_MODELS_TO_DISPLAY} more models[/dim]") + + console.print(table) + + while True: + try: + choice = Prompt.ask( + "\nSelect a model by entering the index number (or type a model name directly)", + default="1" + ).strip() + + # Try to parse as index + try: + index = int(choice) - 1 + if 0 <= index < len(available_models): + return available_models[index]["id"] + else: + console.print(f"[red]Invalid index. Please enter a number between 1 and {len(available_models)}[/red]") + continue + except ValueError: + # Not a number, treat as model name + if choice: + return choice + else: + console.print("[red]Please enter a valid model name or index[/red]") + continue + + except KeyboardInterrupt: + console.print("\n[yellow]Model selection cancelled.[/yellow]") + return None + + +@click.command() +@click.argument("model", required=False) @click.option( "--temperature", "-t", type=float, - help="Sampling temperature between 0 and 2", -) -@click.option( - "--top-p", - type=float, - help="Nucleus sampling parameter between 0 and 1", -) -@click.option( - "--n", - type=int, - help="Number of completions to generate", + default=0.7, + help="Sampling temperature between 0 and 2 (default: 0.7)", ) @click.option( "--max-tokens", @@ -44,65 +98,271 @@ def chat(): help="Maximum number of tokens to generate", ) @click.option( - "--presence-penalty", - type=float, - help="Presence penalty between -2.0 and 2.0", -) -@click.option( - "--frequency-penalty", - type=float, - help="Frequency penalty between -2.0 and 2.0", -) -@click.option( - "--user", + "--system", + "-s", type=str, - help="Unique identifier for the end user", + help="System message to set the behavior of the assistant", ) @click.pass_context -def completions( +def chat( ctx: click.Context, - model: str, - message: tuple[str, ...], - temperature: Optional[float] = None, - top_p: Optional[float] = None, - n: Optional[int] = None, + model: Optional[str], + temperature: float, max_tokens: Optional[int] = None, - presence_penalty: Optional[float] = None, - frequency_penalty: Optional[float] = None, - user: Optional[str] = None, + system: Optional[str] = None, ): - """Create a chat completion""" - if not message: - raise click.UsageError("At least one message is required") - - # Parse messages from role:content format - messages = [] - for msg in message: - try: - role, content = msg.split(":", 1) - messages.append({"role": role.strip(), "content": content.strip()}) - except ValueError: - raise click.BadParameter(f"Invalid message format: {msg}. Expected format: 'role:content'") - + """Interactive chat with streaming responses + + Examples: + + # Chat with a specific model + litellm-proxy chat gpt-4 + + # Chat without specifying model (will show model selection) + litellm-proxy chat + + # Chat with custom settings + litellm-proxy chat gpt-4 --temperature 0.9 --system "You are a helpful coding assistant" + """ + console = Console() + + # If no model specified, show model selection + if not model: + available_models = _get_available_models(ctx) + model = _select_model(console, available_models) + if not model: + console.print("[red]No model selected. Exiting.[/red]") + return + client = ChatClient(ctx.obj["base_url"], ctx.obj["api_key"]) + + # Initialize conversation history + messages: List[Dict[str, Any]] = [] + + # Add system message if provided + if system: + messages.append({"role": "system", "content": system}) + + # Display welcome message + console.print(Panel.fit( + f"[bold blue]LiteLLM Interactive Chat[/bold blue]\n" + f"Model: [green]{model}[/green]\n" + f"Temperature: [yellow]{temperature}[/yellow]\n" + f"Max Tokens: [yellow]{max_tokens or 'unlimited'}[/yellow]\n\n" + f"Type your messages and press Enter. Type '/quit' or '/exit' to end the session.\n" + f"Type '/help' for more commands.", + title="šŸ¤– Chat Session" + )) + try: - response = client.completions( + while True: + # Get user input + try: + user_input = console.input("\n[bold cyan]You:[/bold cyan] ").strip() + except (EOFError, KeyboardInterrupt): + console.print("\n[yellow]Chat session ended.[/yellow]") + break + + # Handle special commands + should_exit, messages, new_model = _handle_special_commands( + console, user_input, messages, system, ctx + ) + + if should_exit: + break + if new_model: + model = new_model + + # Check if this was a special command that was handled (not a normal message) + if user_input.lower().startswith(('/quit', '/exit', '/q', '/help', '/clear', '/history', '/save', '/load', '/model')) or not user_input: + continue + + # Add user message to conversation + messages.append({"role": "user", "content": user_input}) + + # Display assistant label + console.print("\n[bold green]Assistant:[/bold green]") + + # Stream the response + assistant_content = _stream_response( + console=console, + client=client, + model=model, + messages=messages, + temperature=temperature, + max_tokens=max_tokens, + ) + + # Add assistant message to conversation history + if assistant_content: + messages.append({"role": "assistant", "content": assistant_content}) + else: + console.print("[red]Error: No content received from the model[/red]") + + except KeyboardInterrupt: + console.print("\n[yellow]Chat session interrupted.[/yellow]") + + +def _show_help(console: Console): + """Show help for interactive chat commands""" + help_text = """ +[bold]Interactive Chat Commands:[/bold] + +[cyan]/help[/cyan] - Show this help message +[cyan]/quit[/cyan] - Exit the chat session (also /exit, /q) +[cyan]/clear[/cyan] - Clear conversation history +[cyan]/history[/cyan] - Show conversation history +[cyan]/model[/cyan] - Switch to a different model +[cyan]/save [/cyan] - Save conversation to file +[cyan]/load [/cyan] - Load conversation from file + +[bold]Tips:[/bold] +- Your conversation history is maintained during the session +- Use Ctrl+C to interrupt at any time +- Responses are streamed in real-time +- You can switch models mid-conversation with /model + """ + console.print(Panel(help_text, title="Help")) + + +def _show_history(console: Console, messages: List[Dict[str, Any]]): + """Show conversation history""" + if not messages: + console.print("[yellow]No conversation history.[/yellow]") + return + + console.print(Panel.fit("[bold]Conversation History[/bold]", title="History")) + + for i, message in enumerate(messages, 1): + role = message["role"] + content = message["content"] + + if role == "system": + console.print(f"[dim]{i}. [bold magenta]System:[/bold magenta] {content}[/dim]") + elif role == "user": + console.print(f"{i}. [bold cyan]You:[/bold cyan] {content}") + elif role == "assistant": + console.print(f"{i}. [bold green]Assistant:[/bold green] {content[:100]}{'...' if len(content) > 100 else ''}") + + +def _save_conversation(console: Console, messages: List[Dict[str, Any]], command: str): + """Save conversation to a file""" + parts = command.split() + if len(parts) < 2: + console.print("[red]Usage: /save [/red]") + return + + filename = parts[1] + if not filename.endswith('.json'): + filename += '.json' + + try: + with open(filename, 'w') as f: + json.dump(messages, f, indent=2) + console.print(f"[green]Conversation saved to {filename}[/green]") + except Exception as e: + console.print(f"[red]Error saving conversation: {e}[/red]") + + +def _load_conversation(console: Console, command: str, system: Optional[str]) -> List[Dict[str, Any]]: + """Load conversation from a file""" + parts = command.split() + if len(parts) < 2: + console.print("[red]Usage: /load [/red]") + return [] + + filename = parts[1] + if not filename.endswith('.json'): + filename += '.json' + + try: + with open(filename, 'r') as f: + messages = json.load(f) + console.print(f"[green]Conversation loaded from {filename}[/green]") + return messages + except FileNotFoundError: + console.print(f"[red]File not found: {filename}[/red]") + except Exception as e: + console.print(f"[red]Error loading conversation: {e}[/red]") + + # Return empty list or just system message if load failed + if system: + return [{"role": "system", "content": system}] + return [] + + +def _handle_special_commands( + console: Console, + user_input: str, + messages: List[Dict[str, Any]], + system: Optional[str], + ctx: click.Context +) -> tuple[bool, List[Dict[str, Any]], Optional[str]]: + """Handle special chat commands. Returns (should_exit, updated_messages, updated_model)""" + if user_input.lower() in ['/quit', '/exit', '/q']: + console.print("[yellow]Chat session ended.[/yellow]") + return True, messages, None + elif user_input.lower() == '/help': + _show_help(console) + return False, messages, None + elif user_input.lower() == '/clear': + new_messages = [] + if system: + new_messages.append({"role": "system", "content": system}) + console.print("[green]Conversation history cleared.[/green]") + return False, new_messages, None + elif user_input.lower() == '/history': + _show_history(console, messages) + return False, messages, None + elif user_input.lower().startswith('/save'): + _save_conversation(console, messages, user_input) + return False, messages, None + elif user_input.lower().startswith('/load'): + new_messages = _load_conversation(console, user_input, system) + return False, new_messages, None + elif user_input.lower() == '/model': + available_models = _get_available_models(ctx) + new_model = _select_model(console, available_models) + if new_model: + console.print(f"[green]Switched to model: {new_model}[/green]") + return False, messages, new_model + return False, messages, None + elif not user_input: + return False, messages, None + + # Not a special command + return False, messages, None + + +def _stream_response(console: Console, client: ChatClient, model: str, messages: List[Dict[str, Any]], temperature: float, max_tokens: Optional[int]) -> Optional[str]: + """Stream the model response and return the complete content""" + try: + assistant_content = "" + for chunk in client.completions_stream( model=model, messages=messages, temperature=temperature, - top_p=top_p, - n=n, max_tokens=max_tokens, - presence_penalty=presence_penalty, - frequency_penalty=frequency_penalty, - user=user, - ) - rich.print_json(data=response) + ): + if "choices" in chunk and len(chunk["choices"]) > 0: + delta = chunk["choices"][0].get("delta", {}) + content = delta.get("content", "") + if content: + assistant_content += content + console.print(content, end="") + sys.stdout.flush() + + console.print() # Add newline after streaming + return assistant_content if assistant_content else None + except requests.exceptions.HTTPError as e: - click.echo(f"Error: HTTP {e.response.status_code}", err=True) + console.print(f"\n[red]Error: HTTP {e.response.status_code}[/red]") try: error_body = e.response.json() - rich.print_json(data=error_body) + console.print(f"[red]{error_body.get('error', {}).get('message', 'Unknown error')}[/red]") except json.JSONDecodeError: - click.echo(e.response.text, err=True) - raise click.Abort() + console.print(f"[red]{e.response.text}[/red]") + return None + except Exception as e: + console.print(f"\n[red]Error: {str(e)}[/red]") + return None \ No newline at end of file diff --git a/litellm/proxy/client/cli/interface.py b/litellm/proxy/client/cli/interface.py index 78aeb442351..2c6f5f10b4f 100644 --- a/litellm/proxy/client/cli/interface.py +++ b/litellm/proxy/client/cli/interface.py @@ -84,7 +84,7 @@ def show_commands(): ("whoami", "Show current authentication status"), ("models", "Manage and view model configurations"), ("credentials", "Manage API credentials"), - ("chat", "Interactive chat with models"), + ("chat", "Interactive streaming chat with models"), ("http", "Make HTTP requests to the proxy"), ("keys", "Manage API keys"), ("teams", "Manage teams and team assignments"), diff --git a/litellm/proxy/client/client.py b/litellm/proxy/client/client.py index 8ed9a4ff89f..c9066f70de6 100644 --- a/litellm/proxy/client/client.py +++ b/litellm/proxy/client/client.py @@ -1,5 +1,7 @@ from typing import Optional +from litellm.litellm_core_utils.cli_token_utils import get_litellm_gateway_api_key + from .chat import ChatClient from .credentials import CredentialsManagementClient from .http_client import HTTPClient @@ -27,7 +29,7 @@ class Client: timeout: Request timeout in seconds (default: 30) """ self._base_url = base_url.rstrip("/") # Remove trailing slash if present - self._api_key = api_key + self._api_key = get_litellm_gateway_api_key() or api_key # Initialize resource clients diff --git a/litellm/proxy/client/keys.py b/litellm/proxy/client/keys.py index fc307648a2f..50fd7b9d9c9 100644 --- a/litellm/proxy/client/keys.py +++ b/litellm/proxy/client/keys.py @@ -274,14 +274,15 @@ class KeysManagementClient: data["aliases"] = aliases request = requests.Request("POST", url, headers=self._get_headers(), json=data) session = requests.Session() + response_text: Optional[str] = None try: response = session.send(request.prepare()) + response_text = response.text response.raise_for_status() return response.json() - except requests.exceptions.HTTPError as e: - if e.response.status_code == 401: - raise UnauthorizedError(e) - raise + except Exception: + raise Exception(f"Error updating key: {response_text}") + def info(self, key: str, return_request: bool = False) -> Union[Dict[str, Any], requests.Request]: """ diff --git a/litellm/proxy/management_endpoints/key_management_endpoints.py b/litellm/proxy/management_endpoints/key_management_endpoints.py index 026ae9e4056..eb389450f91 100644 --- a/litellm/proxy/management_endpoints/key_management_endpoints.py +++ b/litellm/proxy/management_endpoints/key_management_endpoints.py @@ -1232,13 +1232,11 @@ def validate_key_team_change( ) # Check if the key's user_id is a member of the team + member_object = _get_user_in_team( + team_table=cast(LiteLLM_TeamTableCachedObj, team), user_id=key.user_id + ) if key.user_id is not None: - is_member = False - for member in team.members_with_roles: - if member.user_id == key.user_id: - is_member = True - break - if not is_member: + if not member_object: raise HTTPException( status_code=403, detail=f"User={key.user_id} is not a member of the team={team.team_id}. Check team members via `/team/info`.", @@ -1265,10 +1263,17 @@ def validate_key_team_change( team_obj=team, ): return + # this teams member permissions allow updating a + elif TeamMemberPermissionChecks.does_team_member_have_permissions_for_endpoint( + team_member_object=member_object, + team_table=cast(LiteLLM_TeamTableCachedObj, team), + route=KeyManagementRoutes.KEY_UPDATE.value, + ): + return else: raise HTTPException( status_code=403, - detail=f"User={change_initiated_by.user_id} is not a Proxy Admin or Team Admin for team={team.team_id}.", + detail=f"User={change_initiated_by.user_id} is not a Proxy Admin or Team Admin for team={team.team_id}. Please ask your Proxy Admin to allow this action under 'Member Permissions' for this team.", ) diff --git a/litellm/proxy/management_endpoints/ui_sso.py b/litellm/proxy/management_endpoints/ui_sso.py index 637a852087d..2af940ec654 100644 --- a/litellm/proxy/management_endpoints/ui_sso.py +++ b/litellm/proxy/management_endpoints/ui_sso.py @@ -731,7 +731,6 @@ async def _create_new_cli_key( config={}, spend=0, user_id=user_id, - team_id="litellm-cli", table_name="key", token=key, ) diff --git a/tests/test_litellm/proxy/client/cli/test_chat_commands.py b/tests/test_litellm/proxy/client/cli/test_chat_commands.py deleted file mode 100644 index 1226c3557ff..00000000000 --- a/tests/test_litellm/proxy/client/cli/test_chat_commands.py +++ /dev/null @@ -1,248 +0,0 @@ -import json -import os -import sys -from unittest.mock import MagicMock, patch - -import pytest -import requests -from click.testing import CliRunner - -sys.path.insert( - 0, os.path.abspath("../../..") -) # Adds the parent directory to the system path - - -from litellm.proxy.client.cli.main import cli - - -@pytest.fixture -def mock_chat_client(): - with patch("litellm.proxy.client.cli.commands.chat.ChatClient") as mock: - yield mock - - -@pytest.fixture -def cli_runner(): - return CliRunner() - - -def test_chat_completions_success(cli_runner, mock_chat_client): - # Mock response data - mock_response = { - "id": "chatcmpl-123", - "object": "chat.completion", - "created": 1677858242, - "model": "gpt-4", - "choices": [ - { - "message": { - "role": "assistant", - "content": "Hello! How can I help you today?", - }, - "finish_reason": "stop", - "index": 0, - } - ], - } - mock_instance = mock_chat_client.return_value - mock_instance.completions.return_value = mock_response - - # Run command - result = cli_runner.invoke( - cli, - [ - "chat", - "completions", - "gpt-4", - "-m", - "user:Hello!", - "--temperature", - "0.7", - "--max-tokens", - "100", - ], - ) - - # Verify - assert result.exit_code == 0 - output_data = json.loads(result.output) - assert output_data == mock_response - mock_instance.completions.assert_called_once_with( - model="gpt-4", - messages=[{"role": "user", "content": "Hello!"}], - temperature=0.7, - max_tokens=100, - top_p=None, - n=None, - presence_penalty=None, - frequency_penalty=None, - user=None, - ) - - -def test_chat_completions_multiple_messages(cli_runner, mock_chat_client): - # Mock response data - mock_response = { - "id": "chatcmpl-123", - "object": "chat.completion", - "created": 1677858242, - "model": "gpt-4", - "choices": [ - { - "message": { - "role": "assistant", - "content": "Paris has a population of about 2.2 million.", - }, - "finish_reason": "stop", - "index": 0, - } - ], - } - mock_instance = mock_chat_client.return_value - mock_instance.completions.return_value = mock_response - - # Run command - result = cli_runner.invoke( - cli, - [ - "chat", - "completions", - "gpt-4", - "-m", - "system:You are a helpful assistant", - "-m", - "user:What's the population of Paris?", - ], - ) - - # Verify - assert result.exit_code == 0 - output_data = json.loads(result.output) - assert output_data == mock_response - mock_instance.completions.assert_called_once_with( - model="gpt-4", - messages=[ - {"role": "system", "content": "You are a helpful assistant"}, - {"role": "user", "content": "What's the population of Paris?"}, - ], - temperature=None, - max_tokens=None, - top_p=None, - n=None, - presence_penalty=None, - frequency_penalty=None, - user=None, - ) - - -def test_chat_completions_no_messages(cli_runner, mock_chat_client): - # Run command without any messages - result = cli_runner.invoke(cli, ["chat", "completions", "gpt-4"]) - - # Verify - assert result.exit_code == 2 - assert "At least one message is required" in result.output - mock_instance = mock_chat_client.return_value - mock_instance.completions.assert_not_called() - - -def test_chat_completions_invalid_message_format(cli_runner, mock_chat_client): - # Run command with invalid message format - result = cli_runner.invoke( - cli, ["chat", "completions", "gpt-4", "-m", "invalid-format"] - ) - - # Verify - assert result.exit_code == 2 - assert "Invalid message format" in result.output - mock_instance = mock_chat_client.return_value - mock_instance.completions.assert_not_called() - - -def test_chat_completions_http_error(cli_runner, mock_chat_client): - # Mock HTTP error - mock_instance = mock_chat_client.return_value - mock_error_response = MagicMock() - mock_error_response.status_code = 400 - mock_error_response.json.return_value = { - "error": "Invalid request", - "message": "Invalid model specified", - } - mock_instance.completions.side_effect = requests.exceptions.HTTPError( - response=mock_error_response - ) - - # Run command - result = cli_runner.invoke( - cli, ["chat", "completions", "invalid-model", "-m", "user:Hello"] - ) - - # Verify - assert result.exit_code == 1 - assert "Error: HTTP 400" in result.output - assert "Invalid request" in result.output - assert "Invalid model specified" in result.output - - -def test_chat_completions_all_parameters(cli_runner, mock_chat_client): - # Mock response data - mock_response = { - "id": "chatcmpl-123", - "object": "chat.completion", - "created": 1677858242, - "model": "gpt-4", - "choices": [ - { - "message": { - "role": "assistant", - "content": "Response with all parameters set", - }, - "finish_reason": "stop", - "index": 0, - } - ], - } - mock_instance = mock_chat_client.return_value - mock_instance.completions.return_value = mock_response - - # Run command with all available parameters - result = cli_runner.invoke( - cli, - [ - "chat", - "completions", - "gpt-4", - "-m", - "user:Test message", - "--temperature", - "0.7", - "--top-p", - "0.9", - "--n", - "1", - "--max-tokens", - "100", - "--presence-penalty", - "0.5", - "--frequency-penalty", - "0.5", - "--user", - "test-user", - ], - ) - - # Verify - assert result.exit_code == 0 - output_data = json.loads(result.output) - assert output_data == mock_response - mock_instance.completions.assert_called_once_with( - model="gpt-4", - messages=[{"role": "user", "content": "Test message"}], - temperature=0.7, - top_p=0.9, - n=1, - max_tokens=100, - presence_penalty=0.5, - frequency_penalty=0.5, - user="test-user", - ) diff --git a/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py index cd768e47ae8..da64a866d51 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_key_management_endpoints.py @@ -24,6 +24,7 @@ from litellm.proxy.management_endpoints.key_management_endpoints import ( _common_key_generation_helper, _list_key_helper, prepare_key_update_data, + validate_key_team_change, ) from litellm.proxy.proxy_server import app @@ -1033,3 +1034,60 @@ async def test_unblock_key_invalid_key_format(monkeypatch): assert exc_info.value.code == "400" assert "Invalid key format" in str(exc_info.value.message) + + +def test_validate_key_team_change_with_member_permissions(): + """ + Test validate_key_team_change function with team member permissions. + + This test covers the new logic that allows team members with specific + permissions to update keys, not just team admins. + """ + from unittest.mock import MagicMock, patch + + from litellm.proxy._types import KeyManagementRoutes + + # Create mock objects + mock_key = MagicMock() + mock_key.user_id = "test-user-123" + mock_key.models = ["gpt-4"] + mock_key.tpm_limit = None + mock_key.rpm_limit = None + + mock_team = MagicMock() + mock_team.team_id = "test-team-456" + mock_team.members_with_roles = [] + mock_team.tpm_limit = None + mock_team.rpm_limit = None + + mock_change_initiator = MagicMock() + mock_change_initiator.user_id = "test-user-123" + + mock_router = MagicMock() + + # Mock the member object returned by _get_user_in_team + mock_member_object = MagicMock() + + with patch('litellm.proxy.management_endpoints.key_management_endpoints.can_team_access_model'): + with patch('litellm.proxy.management_endpoints.key_management_endpoints._get_user_in_team') as mock_get_user: + with patch('litellm.proxy.management_endpoints.key_management_endpoints._is_user_team_admin') as mock_is_admin: + with patch('litellm.proxy.management_endpoints.key_management_endpoints.TeamMemberPermissionChecks.does_team_member_have_permissions_for_endpoint') as mock_has_perms: + + mock_get_user.return_value = mock_member_object + mock_is_admin.return_value = False + mock_has_perms.return_value = True + + # This should not raise an exception due to member permissions + validate_key_team_change( + key=mock_key, + team=mock_team, + change_initiated_by=mock_change_initiator, + llm_router=mock_router + ) + + # Verify the permission check was called with correct parameters + mock_has_perms.assert_called_once_with( + team_member_object=mock_member_object, + team_table=mock_team, + route=KeyManagementRoutes.KEY_UPDATE.value + ) From e437273ad52e2f1bd93a6d22574f9833e38839b0 Mon Sep 17 00:00:00 2001 From: Franklin <5235904+mrFranklin@users.noreply.github.com> Date: Thu, 25 Sep 2025 00:57:21 +0800 Subject: [PATCH 64/65] doc: make the README document clearer (#14860) * Update README.md * Update README.md --- README.md | 33 +++++++++++++-------------------- 1 file changed, 13 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index f74889fbb27..0918d2b1fa4 100644 --- a/README.md +++ b/README.md @@ -350,13 +350,21 @@ curl 'http://0.0.0.0:4000/key/generate' \ [**Read the Docs**](https://docs.litellm.ai/docs/) -## Contributing +## Run in Developer mode +### Services +1. Setup .env file in root +2. Run dependant services `docker-compose up db prometheus` -Interested in contributing? Contributions to LiteLLM Python SDK, Proxy Server, and LLM integrations are both accepted and highly encouraged! +### Backend +1. (In root) create virtual environment `python -m venv .venv` +2. Activate virtual environment `source .venv/bin/activate` +3. Install dependencies `pip install -e ".[all]"` +4. Start proxy backend `python litellm/proxy_cli.py` -**Quick start:** `git clone` ā†’ `make install-dev` ā†’ `make format` ā†’ `make lint` ā†’ `make test-unit` - -See our comprehensive [Contributing Guide (CONTRIBUTING.md)](CONTRIBUTING.md) for detailed instructions. +### Frontend +1. Navigate to `ui/litellm-dashboard` +2. Install dependencies `npm install` +3. Run `npm run dev` to start the dashboard # Enterprise For companies that need better security, user management and professional support @@ -434,18 +442,3 @@ All these checks must pass before your PR can be merged. -## Run in Developer mode -### Services -1. Setup .env file in root -2. Run dependant services `docker-compose up db prometheus` - -### Backend -1. (In root) create virtual environment `python -m venv .venv` -2. Activate virtual environment `source .venv/bin/activate` -3. Install dependencies `pip install -e ".[all]"` -4. Start proxy backend `python3 /path/to/litellm/proxy_cli.py` - -### Frontend -1. Navigate to `ui/litellm-dashboard` -2. Install dependencies `npm install` -3. Run `npm run dev` to start the dashboard From 22eef373eba848b02969f25d5c49b555ade8b57e Mon Sep 17 00:00:00 2001 From: onlylonly Date: Thu, 25 Sep 2025 00:58:23 +0800 Subject: [PATCH 65/65] feat: New model - Add support for Qwen models family & Deepseek 3.1 to Amazon Bedrock (#14845) * New model - Add Bedrock deepseek v3.1 model - "deepseek.v3-v1:0" * New model - Add Bedrock Qwen models - "qwen.qwen3-coder-480b-a35b-v1:0", "qwen.qwen3-235b-a22b-2507-v1:0", "qwen.qwen3-coder-30b-a3b-v1:0", "qwen.qwen3-32b-v1:0" * fix: add "deepseek.v3-v1:0" in litellm/model_prices_and_context_window_backup.json --- litellm/constants.py | 5 ++ ...odel_prices_and_context_window_backup.json | 60 +++++++++++++++++++ model_prices_and_context_window.json | 60 +++++++++++++++++++ 3 files changed, 125 insertions(+) diff --git a/litellm/constants.py b/litellm/constants.py index 005eb2bb6d0..6e70ae0671f 100644 --- a/litellm/constants.py +++ b/litellm/constants.py @@ -812,6 +812,11 @@ BEDROCK_EMBEDDING_PROVIDERS_LITERAL = Literal[ ] BEDROCK_CONVERSE_MODELS = [ + "qwen.qwen3-coder-480b-a35b-v1:0", + "qwen.qwen3-235b-a22b-2507-v1:0", + "qwen.qwen3-coder-30b-a3b-v1:0", + "qwen.qwen3-32b-v1:0", + "deepseek.v3-v1:0", "openai.gpt-oss-20b-1:0", "openai.gpt-oss-120b-1:0", "anthropic.claude-opus-4-1-20250805-v1:0", diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 832ff36bfb8..b0261d1bd43 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -7203,6 +7203,18 @@ "supports_prompt_caching": true, "supports_tool_choice": true }, + "deepseek.v3-v1:0": { + "input_cost_per_token": 5.8e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 163840, + "max_output_tokens": 81920, + "max_tokens": 163840, + "mode": "chat", + "output_cost_per_token": 1.68e-06, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, "dolphin": { "input_cost_per_token": 5e-07, "litellm_provider": "nlp_cloud", @@ -17520,6 +17532,54 @@ "mode": "chat", "output_cost_per_token": 2.8e-07 }, + "qwen.qwen3-coder-480b-a35b-v1:0": { + "input_cost_per_token": 2.2e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262000, + "max_output_tokens": 65536, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.8e-06, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-235b-a22b-2507-v1:0": { + "input_cost_per_token": 2.2e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262144, + "max_output_tokens": 131072, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 8.8e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-coder-30b-a3b-v1:0": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262144, + "max_output_tokens": 131072, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 6.0e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-32b-v1:0": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 131072, + "max_output_tokens": 16384, + "max_tokens": 131072, + "mode": "chat", + "output_cost_per_token": 6.0e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, "recraft/recraftv2": { "litellm_provider": "recraft", "mode": "image_generation", diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 832ff36bfb8..37be4e283aa 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -7203,6 +7203,18 @@ "supports_prompt_caching": true, "supports_tool_choice": true }, + "deepseek.v3-v1:0": { + "input_cost_per_token": 5.8e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 163840, + "max_output_tokens": 81920, + "max_tokens": 163840, + "mode": "chat", + "output_cost_per_token": 1.68e-06, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, "dolphin": { "input_cost_per_token": 5e-07, "litellm_provider": "nlp_cloud", @@ -17520,6 +17532,54 @@ "mode": "chat", "output_cost_per_token": 2.8e-07 }, + "qwen.qwen3-coder-480b-a35b-v1:0": { + "input_cost_per_token": 2.2e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262000, + "max_output_tokens": 65536, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 1.8e-06, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-235b-a22b-2507-v1:0": { + "input_cost_per_token": 2.2e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262144, + "max_output_tokens": 131072, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 8.8e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-coder-30b-a3b-v1:0": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 262144, + "max_output_tokens": 131072, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 6.0e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "qwen.qwen3-32b-v1:0": { + "input_cost_per_token": 1.5e-07, + "litellm_provider": "bedrock_converse", + "max_input_tokens": 131072, + "max_output_tokens": 16384, + "max_tokens": 131072, + "mode": "chat", + "output_cost_per_token": 6.0e-07, + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, "recraft/recraftv2": { "litellm_provider": "recraft", "mode": "image_generation",