synth-ai 0.2.0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/lm/provider_support/suppress_logging.py

@@ -0,0 +1,31 @@
+import logging
+
+
+class ExcludeLangfuseMessagesFilter(logging.Filter):
+    def filter(self, record):
+        # Return False to exclude the record, True to include it
+        message = record.getMessage()
+        excluded_messages = [
+            "No observation found in the current context",
+            "No trace found in the current context",
+            "Adding event to partition",
+        ]
+        return not any(msg in message for msg in excluded_messages)
+
+
+# Configure root logger
+root_logger = logging.getLogger()
+root_logger.addFilter(ExcludeLangfuseMessagesFilter())
+root_logger.setLevel(logging.ERROR)
+
+# Configure langfuse logger
+langfuse_logger = logging.getLogger("langfuse")
+langfuse_logger.addFilter(ExcludeLangfuseMessagesFilter())
+langfuse_logger.setLevel(logging.CRITICAL)
+langfuse_logger.propagate = False
+
+# Also configure the synth_sdk logger
+synth_logger = logging.getLogger("synth_sdk")
+synth_logger.addFilter(ExcludeLangfuseMessagesFilter())
+synth_logger.setLevel(logging.ERROR)
+synth_logger.propagate = False

synth_ai/{zyk/lms → lm}/structured_outputs/handler.py

@@ -5,17 +5,17 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.core.exceptions import StructuredOutputCoercionFailureException
-from synth_ai.zyk.lms.structured_outputs.inject import (
+from synth_ai.lm.core.exceptions import StructuredOutputCoercionFailureException
+from synth_ai.lm.structured_outputs.inject import (
     inject_structured_output_instructions,
 )
-from synth_ai.zyk.lms.structured_outputs.rehabilitate import (
+from synth_ai.lm.structured_outputs.rehabilitate import (
     fix_errant_forced_async,
     fix_errant_forced_sync,
     pull_out_structured_output,
 )
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.zyk.lms.constants import SPECIAL_BASE_TEMPS
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 
 logger = logging.getLogger(__name__)
 
@@ -31,15 +31,11 @@ class StructuredHandlerBase(ABC):
         core_client: VendorBase,
         retry_client: VendorBase,
         handler_params: Optional[Dict[str, Any]] = None,
-        structured_output_mode: Literal[
-            "stringified_json", "forced_json"
-        ] = "stringified_json",
+        structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
     ):
         self.core_client = core_client
         self.retry_client = retry_client
-        self.handler_params = (
-            handler_params if handler_params is not None else {"retries": 3}
-        )
+        self.handler_params = handler_params if handler_params is not None else {"retries": 3}
         self.structured_output_mode = structured_output_mode
 
     async def call_async(
@@ -142,22 +138,18 @@ class StringifiedJSONHandler(StructuredHandlerBase):
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
-        #ogger.info(f"Processing structured output call for model: {model}")
+        # ogger.info(f"Processing structured output call for model: {model}")
         assert callable(api_call_method), "api_call_method must be a callable"
-        assert (
-            response_model is not None
-        ), "Don't use this handler for unstructured outputs"
+        assert response_model is not None, "Don't use this handler for unstructured outputs"
         remaining_retries = self.handler_params.get("retries", 2)
         previously_failed_error_messages = []
         structured_output = None
 
         while remaining_retries > 0:
-            messages_with_json_formatting_instructions = (
-                inject_structured_output_instructions(
-                    messages=messages,
-                    response_model=response_model,
-                    previously_failed_error_messages=previously_failed_error_messages,
-                )
+            messages_with_json_formatting_instructions = inject_structured_output_instructions(
+                messages=messages,
+                response_model=response_model,
+                previously_failed_error_messages=previously_failed_error_messages,
             )
             t0 = time.time()
             raw_text_response_or_cached_hit = await api_call_method(
@@ -167,26 +159,24 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
                 reasoning_effort=reasoning_effort,
             )
-            #logger.debug(f"Time to get response: {time.time() - t0:.2f}s")
+            # logger.debug(f"Time to get response: {time.time() - t0:.2f}s")
 
             # Check if we got a cached BaseLMResponse
-            assert (
-                type(raw_text_response_or_cached_hit) in [str, BaseLMResponse]
-            ), f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
+            assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
+                f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
+            )
             if type(raw_text_response_or_cached_hit) == BaseLMResponse:
-                #print("Got cached hit, returning directly")
+                # print("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
                 raw_text_response = raw_text_response_or_cached_hit
-            #logger.debug(f"Raw response from model:\n{raw_text_response}")
+            # logger.debug(f"Raw response from model:\n{raw_text_response}")
 
-            #print("Trying to parse structured output")
+            # print("Trying to parse structured output")
             try:
-                structured_output = pull_out_structured_output(
-                    raw_text_response, response_model
-                )
+                structured_output = pull_out_structured_output(raw_text_response, response_model)
 
-                #print("Successfully parsed structured output on first attempt")
+                # print("Successfully parsed structured output on first attempt")
                 break
             except Exception as e:
                 logger.warning(f"Failed to parse structured output: {str(e)}")
@@ -198,8 +188,12 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                         response_model,
                         "gpt-4o-mini",
                     )
-                    assert isinstance(structured_output, BaseModel), "Structured output must be a Pydantic model"
-                    assert not isinstance(structured_output, BaseLMResponse), "Got BaseLMResponse instead of Pydantic model"
+                    assert isinstance(structured_output, BaseModel), (
+                        "Structured output must be a Pydantic model"
+                    )
+                    assert not isinstance(structured_output, BaseLMResponse), (
+                        "Got BaseLMResponse instead of Pydantic model"
+                    )
                     print("Successfully fixed and parsed structured output")
                     break
                 except Exception as e:
@@ -212,13 +206,15 @@ class StringifiedJSONHandler(StructuredHandlerBase):
 
         if structured_output is None:
             logger.error("Failed to get structured output after all retries")
-            raise StructuredOutputCoercionFailureException(
-                "Failed to get structured output"
-            )
-        #print("Successfully parsed structured output")
-        #print(structured_output)
-        assert isinstance(structured_output, BaseModel), "Structured output must be a Pydantic model"
-        assert not isinstance(structured_output, BaseLMResponse),"Got BaseLMResponse instead of Pydantic model" 
+            raise StructuredOutputCoercionFailureException("Failed to get structured output")
+        # print("Successfully parsed structured output")
+        # print(structured_output)
+        assert isinstance(structured_output, BaseModel), (
+            "Structured output must be a Pydantic model"
+        )
+        assert not isinstance(structured_output, BaseLMResponse), (
+            "Got BaseLMResponse instead of Pydantic model"
+        )
         return BaseLMResponse(
             raw_response=raw_text_response,
             structured_output=structured_output,
@@ -235,22 +231,18 @@ class StringifiedJSONHandler(StructuredHandlerBase):
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
-        #logger.info(f"Processing structured output call for model: {model}")
+        # logger.info(f"Processing structured output call for model: {model}")
         assert callable(api_call_method), "api_call_method must be a callable"
-        assert (
-            response_model is not None
-        ), "Don't use this handler for unstructured outputs"
+        assert response_model is not None, "Don't use this handler for unstructured outputs"
         remaining_retries = self.handler_params.get("retries", 2)
         previously_failed_error_messages = []
         structured_output = None
 
         while remaining_retries > 0:
-            messages_with_json_formatting_instructions = (
-                inject_structured_output_instructions(
-                    messages=messages,
-                    response_model=response_model,
-                    previously_failed_error_messages=previously_failed_error_messages,
-                )
+            messages_with_json_formatting_instructions = inject_structured_output_instructions(
+                messages=messages,
+                response_model=response_model,
+                previously_failed_error_messages=previously_failed_error_messages,
             )
             t0 = time.time()
             raw_text_response_or_cached_hit = api_call_method(
@@ -263,21 +255,19 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             logger.debug(f"Time to get response: {time.time() - t0:.2f}s")
 
             # Check if we got a cached BaseLMResponse
-            assert (
-                type(raw_text_response_or_cached_hit) in [str, BaseLMResponse]
-            ), f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
+            assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
+                f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
+            )
             if type(raw_text_response_or_cached_hit) == BaseLMResponse:
                 logger.info("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
-            else:   
+            else:
                 raw_text_response = raw_text_response_or_cached_hit
-            #logger.debug(f"Raw response from model:\n{raw_text_response}")
+            # logger.debug(f"Raw response from model:\n{raw_text_response}")
 
             try:
-                structured_output = pull_out_structured_output(
-                    raw_text_response, response_model
-                )
-                #print("Successfully parsed structured output on first attempt")
+                structured_output = pull_out_structured_output(raw_text_response, response_model)
+                # print("Successfully parsed structured output on first attempt")
                 break
             except Exception as e:
                 logger.warning(f"Failed to parse structured output: {str(e)}")
@@ -296,13 +286,11 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                     remaining_retries -= 1
                     logger.warning(f"Retries remaining: {remaining_retries}")
 
-        #print("Successfully parsed structured output")
-        #print(structured_output)
+        # print("Successfully parsed structured output")
+        # print(structured_output)
         if structured_output is None:
             logger.error("Failed to get structured output after all retries")
-            raise StructuredOutputCoercionFailureException(
-                "Failed to get structured output"
-            )
+            raise StructuredOutputCoercionFailureException("Failed to get structured output")
         return BaseLMResponse(
             raw_response=raw_text_response,
             structured_output=structured_output,
@@ -341,9 +329,7 @@ class ForcedJSONHandler(StructuredHandlerBase):
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
         # print("Forced JSON")
-        assert (
-            response_model is not None
-        ), "Don't use this handler for unstructured outputs"
+        assert response_model is not None, "Don't use this handler for unstructured outputs"
         return await api_call_method(
             messages=messages,
             model=model,
@@ -363,9 +349,7 @@ class ForcedJSONHandler(StructuredHandlerBase):
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
-        assert (
-            response_model is not None
-        ), "Don't use this handler for unstructured outputs"
+        assert response_model is not None, "Don't use this handler for unstructured outputs"
         return api_call_method(
             messages=messages,
             model=model,
@@ -390,9 +374,7 @@ class StructuredOutputHandler:
     ):
         self.mode = mode
         if self.mode == "stringified_json":
-            self.handler = StringifiedJSONHandler(
-                core_client, retry_client, handler_params
-            )
+            self.handler = StringifiedJSONHandler(core_client, retry_client, handler_params)
         elif self.mode == "forced_json":
             # print("Forced JSON")
             self.handler = ForcedJSONHandler(core_client, retry_client, handler_params)
@@ -413,9 +395,7 @@ class StructuredOutputHandler:
             messages=messages,
             model=model,
             response_model=response_model,
-            temperature=lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0.0)
-            ),
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0.0)),
             use_ephemeral_cache_only=use_ephemeral_cache_only,
             reasoning_effort=reasoning_effort,
         )
@@ -433,9 +413,7 @@ class StructuredOutputHandler:
             messages=messages,
             model=model,
             response_model=response_model,
-            temperature=lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0.0)
-            ),
+            temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0.0)),
             use_ephemeral_cache_only=use_ephemeral_cache_only,
             reasoning_effort=reasoning_effort,
         )

synth_ai/{zyk/lms → lm}/structured_outputs/inject.py

@@ -41,9 +41,7 @@ def generate_type_map() -> Dict[Any, str]:
                 # Handle generic Dict type
                 type_map[Dict] = "Dict[Any,Any]"
                 # Provide both key and value types for Dict
-                type_map[Dict[base_type, base_type]] = (
-                    f"{collection_name}[{name},{name}]"
-                )
+                type_map[Dict[base_type, base_type]] = f"{collection_name}[{name},{name}]"
                 # Handle Dict[Any, Any] explicitly
                 type_map[Dict[Any, Any]] = "Dict[Any,Any]"
             else:
@@ -189,9 +187,7 @@ def get_example_value(type_hint):
         first_type = non_none_types[0]
         union_docs = []
 
-        if all(
-            isinstance(t, type) and issubclass(t, BaseModel) for t in non_none_types
-        ):
+        if all(isinstance(t, type) and issubclass(t, BaseModel) for t in non_none_types):
             # Generate examples for all union variants
             for t in non_none_types:
                 example = {}
@@ -211,10 +207,7 @@ def get_example_value(type_hint):
             for field_name, field_info in first_type.model_fields.items():
                 if get_origin(field_info.annotation) is Literal:
                     literal_args = get_args(field_info.annotation)
-                    if (
-                        isinstance(example[field_name], dict)
-                        and "value" in example[field_name]
-                    ):
+                    if isinstance(example[field_name], dict) and "value" in example[field_name]:
                         example[field_name]["value"] = literal_args[0]
                     else:
                         example[field_name] = literal_args[0]
@@ -246,25 +239,18 @@ def add_json_instructions_to_messages(
             field = response_model.model_fields[key]  # Updated for Pydantic v2
 
             # Adjusted for Pydantic v2
-            field_description = (
-                field.description if hasattr(field, "description") else None
-            )
+            field_description = field.description if hasattr(field, "description") else None
 
             if field_description:
                 stringified_fields[key] = (example_value, field_description)
             else:
                 stringified_fields[key] = example_value
         example_json = json.dumps(
-            {
-                k: v[0] if isinstance(v, tuple) else v
-                for k, v in stringified_fields.items()
-            },
+            {k: v[0] if isinstance(v, tuple) else v for k, v in stringified_fields.items()},
             indent=4,
         )
         description_comments = "\n".join(
-            f"// {k}: {v[1]}"
-            for k, v in stringified_fields.items()
-            if isinstance(v, tuple)
+            f"// {k}: {v[1]}" for k, v in stringified_fields.items() if isinstance(v, tuple)
         )
 
         # print("Example JSON", example_json)

synth_ai/{zyk/lms → lm}/structured_outputs/rehabilitate.py

@@ -6,19 +6,15 @@ from typing import Dict, List, Type, Union
 
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.vendors.base import VendorBase
-from synth_ai.zyk.lms.vendors.core.openai_api import OpenAIStructuredOutputClient
+from synth_ai.lm.vendors.base import VendorBase
+from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 
-def pull_out_structured_output(
-    response_raw: str, response_model: Type[BaseModel]
-) -> BaseModel:
+def pull_out_structured_output(response_raw: str, response_model: Type[BaseModel]) -> BaseModel:
     logger = logging.getLogger(__name__)
-    #logger.debug(f"Raw response received: {response_raw}")
+    # logger.debug(f"Raw response received: {response_raw}")
 
-    assert isinstance(
-        response_raw, str
-    ), f"Response raw is not a string: {type(response_raw)}"
+    assert isinstance(response_raw, str), f"Response raw is not a string: {type(response_raw)}"
 
     # Use regex to extract JSON content within ```json ... ```
     json_pattern = re.compile(r"```json\s*(\{.*\})\s*```", re.DOTALL)
@@ -52,9 +48,7 @@ def pull_out_structured_output(
                 f"Failed to parse response as {response_model}: {inner_e} - {response_prepared}"
             )
     except Exception as e:
-        raise ValueError(
-            f"Failed to parse response as {response_model}: {e} - {response_prepared}"
-        )
+        raise ValueError(f"Failed to parse response as {response_model}: {e} - {response_prepared}")
     assert isinstance(final, BaseModel), "Structured output must be a Pydantic model"
     return final
 

synth_ai/{zyk/lms → lm}/vendors/core/anthropic_api.py

@@ -5,13 +5,13 @@ import anthropic
 import pydantic
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.caching.initialize import (
+from synth_ai.lm.caching.initialize import (
     get_cache_handler,
 )
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.zyk.lms.constants import SPECIAL_BASE_TEMPS, CLAUDE_REASONING_MODELS, SONNET_37_BUDGETS
-from synth_ai.zyk.lms.vendors.core.openai_api import OpenAIStructuredOutputClient
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS, CLAUDE_REASONING_MODELS, SONNET_37_BUDGETS
+from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 ANTHROPIC_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (anthropic.APIError,)
 
@@ -24,9 +24,7 @@ class AnthropicAPI(VendorBase):
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[
-            Type[Exception], ...
-        ] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: Tuple[Type[Exception], ...] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
         reasoning_effort: str = "high",
     ):
@@ -53,9 +51,9 @@ class AnthropicAPI(VendorBase):
         tools: Optional[List[BaseTool]] = None,
         **vendor_params: Dict[str, Any],
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
+        assert lm_config.get("response_model", None) is None, (
+            "response_model is not supported for standard calls"
+        )
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
@@ -70,9 +68,7 @@ class AnthropicAPI(VendorBase):
             "messages": messages[1:],
             "model": model,
             "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
+            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
         }
 
         # Add tools if provided
@@ -86,12 +82,12 @@ class AnthropicAPI(VendorBase):
             create_sig = inspect.signature(self.async_client.messages.create)
             if "thinking" in create_sig.parameters and model in CLAUDE_REASONING_MODELS:
                 if reasoning_effort in ["high", "medium"]:
-                    budget = SONNET_37_BUDGETS[reasoning_effort]    
+                    budget = SONNET_37_BUDGETS[reasoning_effort]
                     api_params["thinking"] = {
                         "type": "enabled",
                         "budget_tokens": budget,
                     }
-                    api_params["max_tokens"] = budget+4096
+                    api_params["max_tokens"] = budget + 4096
                     api_params["temperature"] = 1
         except (ImportError, AttributeError, TypeError):
             pass
@@ -146,12 +142,10 @@ class AnthropicAPI(VendorBase):
         tools: Optional[List[BaseTool]] = None,
         **vendor_params: Dict[str, Any],
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
-        used_cache_handler = get_cache_handler(
-            use_ephemeral_cache_only=use_ephemeral_cache_only
+        assert lm_config.get("response_model", None) is None, (
+            "response_model is not supported for standard calls"
         )
+        used_cache_handler = get_cache_handler(use_ephemeral_cache_only=use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
             model, messages, lm_config=lm_config, tools=tools
@@ -165,9 +159,7 @@ class AnthropicAPI(VendorBase):
             "messages": messages[1:],
             "model": model,
             "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
+            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
         }
 
         # Add tools if provided
@@ -188,7 +180,7 @@ class AnthropicAPI(VendorBase):
                         "type": "enabled",
                         "budget_tokens": budget,
                     }
-                    api_params["max_tokens"] = budget+4096
+                    api_params["max_tokens"] = budget + 4096
                     api_params["temperature"] = 1
         except (ImportError, AttributeError, TypeError):
             pass
@@ -241,13 +233,12 @@ class AnthropicAPI(VendorBase):
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
             if model in CLAUDE_REASONING_MODELS:
-
-                #if reasoning_effort in ["high", "medium"]:
+                # if reasoning_effort in ["high", "medium"]:
                 budgets = SONNET_37_BUDGETS
                 budget = budgets[reasoning_effort]
-                max_tokens = budget+4096
+                max_tokens = budget + 4096
                 temperature = 1
-                
+
                 response = await self.async_client.messages.create(
                     system=messages[0]["content"],
                     messages=messages[1:],
@@ -303,7 +294,7 @@ class AnthropicAPI(VendorBase):
                 if reasoning_effort in ["high", "medium"]:
                     budgets = SONNET_37_BUDGETS
                     budget = budgets[reasoning_effort]
-                    max_tokens = budget+4096
+                    max_tokens = budget + 4096
                     temperature = 1
                 response = self.sync_client.messages.create(
                     system=messages[0]["content"],