lucidicai 1.2.14__tar.gz → 1.2.16__tar.gz

{lucidicai-1.2.14 → lucidicai-1.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 1.2.14
+Version: 1.2.16
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/__init__.py

@@ -101,9 +101,11 @@ def init(
     agent_id: Optional[str] = None,
     task: Optional[str] = None,
     providers: Optional[List[ProviderType]] = [],
+    production_monitoring: Optional[bool] = False,
     mass_sim_id: Optional[str] = None,
     rubrics: Optional[list] = None,
     tags: Optional[list] = None,
+    masking_function = None,
 ) -> str:
     """
     Initialize the Lucidic client.
@@ -117,6 +119,7 @@ def init(
         mass_sim_id: Optional mass simulation ID, if session is to be part of a mass simulation.
         rubrics: Optional rubrics for evaluation, list of strings.
         tags: Optional tags for the session, list of strings.
+        masking_function: Optional function to mask sensitive data.
     
     Raises:
         InvalidOperationError: If the client is already initialized.
@@ -137,6 +140,13 @@ def init(
     if not getattr(client, 'initialized', False):
         client = Client(lucidic_api_key=lucidic_api_key, agent_id=agent_id)
     
+    if not production_monitoring:
+        production_monitoring = os.getenv("LUCIDIC_PRODUCTION_MONITORING", False)
+        if production_monitoring == "True":
+            production_monitoring = True
+        else:
+            production_monitoring = False
+    
     # Set up providers
     _setup_providers(client, providers)
     session_id = client.init_session(
@@ -144,8 +154,11 @@ def init(
         mass_sim_id=mass_sim_id,
         task=task,
         rubrics=rubrics,
-        tags=tags
+        tags=tags,
+        production_monitoring=production_monitoring,
     )
+    if masking_function:
+        client.masking_function = masking_function
     logger.info("Session initialized successfully")
     return session_id
 
@@ -154,7 +167,8 @@ def continue_session(
     session_id: str,
     lucidic_api_key: Optional[str] = None,
     agent_id: Optional[str] = None,
-    providers: Optional[List[ProviderType]] = []
+    providers: Optional[List[ProviderType]] = [],
+    masking_function = None,
 ):
     if lucidic_api_key is None:
         lucidic_api_key = os.getenv("LUCIDIC_API_KEY", None)
@@ -177,6 +191,8 @@ def continue_session(
     # Set up providers
     _setup_providers(client, providers)
     session_id = client.continue_session(session_id=session_id)
+    if masking_function:
+        client.masking_function = masking_function
     logger.info(f"Session {session_id} continuing...")
     return session_id  # For consistency
 

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/client.py

@@ -4,6 +4,7 @@ from datetime import datetime, timezone
 from typing import Optional, Tuple
 
 import requests
+import logging
 from requests.adapters import HTTPAdapter, Retry
 from urllib3.util import Retry
 
@@ -30,6 +31,7 @@ class Client:
         self.providers = []
         self.api_key = lucidic_api_key
         self.agent_id = agent_id
+        self.masking_function = None
         self.request_session = requests.Session()
         retry_cfg = Retry(
             total=3,                     # 3 attempts in total
@@ -73,7 +75,8 @@ class Client:
         mass_sim_id: Optional[str] = None,
         task: Optional[str] = None,
         rubrics: Optional[list] = None,
-        tags: Optional[list] = None
+        tags: Optional[list] = None,
+        production_monitoring: Optional[bool] = False
     ) -> None:
         self.session = Session(
             agent_id=self.agent_id,
@@ -81,7 +84,8 @@ class Client:
             mass_sim_id=mass_sim_id,
             task=task,
             rubrics=rubrics,
-            tags=tags
+            tags=tags,
+            production_monitoring=production_monitoring
         )
         self.initialized = True
         return self.session.session_id
@@ -147,4 +151,16 @@ class Client:
             response.raise_for_status()
         except requests.exceptions.HTTPError as e:
             raise InvalidOperationError(f"Request to Lucidic AI Backend failed: {e.response.text}")
-        return response.json()
+        return response.json()
+
+    def mask(self, data):
+        if not self.masking_function:
+            return data
+        if not data:
+            return data
+        try:
+            return self.masking_function(data)
+        except Exception as e:
+            logger = logging.getLogger('Lucidic')
+            logger.error(f"Error in custom masking function: {repr(e)}")
+            return "<Error in custom masking function, this is a fully-masked placeholder>"

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/event.py

@@ -40,8 +40,8 @@ class Event:
             self.is_finished = kwargs['is_finished']
         request_data = {
             "event_id": self.event_id,
-            "description": kwargs.get("description", None),
-            "result": kwargs.get("result", None),
+            "description": Client().mask(kwargs.get("description", None)),
+            "result": Client().mask(kwargs.get("result", None)),
             "is_finished": self.is_finished, 
             "cost_added": kwargs.get("cost_added", None),
             "model": kwargs.get("model", None), 

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/model_pricing.py

@@ -141,6 +141,7 @@ MODEL_PRICING = {
     "deepseek-ai/deepseek-r1-distill-llama-70b": {"input": 0.75, "output": 0.99},
     "deepseek-coder": {"input": 0.14, "output": 0.28},
     "deepseek-chat": {"input": 0.14, "output": 0.28},
+    "deepseek/deepseek-v3-0324": {"input": 0.14, "output": 0.28},
     
     # Qwen Models
     "qwen-qwq-32b": {"input": 0.29, "output": 0.39},
@@ -148,6 +149,8 @@ MODEL_PRICING = {
     "qwen-turbo": {"input": 0.3, "output": 0.6},
     "qwen-plus": {"input": 0.5, "output": 2.0},
     "qwen-max": {"input": 2.0, "output": 6.0},
+    "qwen2.5-32b-instruct": {"input": 0.7, "output": "2.8"},
+    "qwen2.5-max": {"input": 1.6, "output": 6.4},
     
     # Google Gemma Models
     "gemma-2-9b": {"input": 0.20, "output": 0.20},
@@ -163,7 +166,14 @@ MODEL_PRICING = {
     "pplx-7b-chat": {"input": 0.07, "output": 0.28},
     "pplx-70b-chat": {"input": 0.7, "output": 2.8},
     "pplx-7b-online": {"input": 0.07, "output": 0.28},
-    "pplx-70b-online": {"input": 0.7, "output": 2.8}
+    "pplx-70b-online": {"input": 0.7, "output": 2.8},
+
+    # Grok Models
+    "grok-3-latest": {"input": 3, "output": 15},
+    "grok-3": {"input": 3, "output": 15},
+    "grok-3-fast": {"input": 5, "output": 25},
+    "grok-3-mini": {"input": 0.3, "output": 0.5},
+    "grok-3-mini-fast": {"input": 0.6, "output": 4},
 
 }
 
@@ -179,6 +189,7 @@ PROVIDER_AVERAGES = {
     "qwen": {"input": 0.5, "output": 1.0},          # Qwen average
     "together": {"input": 0.15, "output": 0.15},    # Together AI average
     "perplexity": {"input": 0.4, "output": 1.5},    # Perplexity average
+    "grok": {"input": 2.4, "output": 12},           # Grok average
 }
 
 def get_provider_from_model(model: str) -> str:
@@ -205,6 +216,8 @@ def get_provider_from_model(model: str) -> str:
         return "together"
     elif any(pplx in model_lower for pplx in ["pplx", "perplexity"]):
         return "perplexity"
+    elif any(grok in model_lower for grok in ["grok", "xAI"]):
+        return "grok"
     else:
         return "unknown"
 

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/providers/anthropic_handler.py

@@ -51,7 +51,6 @@ class AnthropicHandler(BaseProvider):
         return " ".join(descriptions), screenshots
 
     def handle_response(self, response, kwargs):
-        event = Client().session.active_step
 
         # for synchronous streaming responses
         if isinstance(response, Stream):
@@ -222,9 +221,6 @@ class AnthropicHandler(BaseProvider):
         self.original_create_async = AsyncMessages.create
         
         def patched_create(*args, **kwargs):            
-            step = Client().session.active_step
-            if not step:
-                return self.original_create(*args, **kwargs)
             description, images = self._format_messages(kwargs.get("messages", []))
             
             event_id = Client().session.create_event(
@@ -237,9 +233,6 @@ class AnthropicHandler(BaseProvider):
             return self.handle_response(result, kwargs)
         
         async def patched_create_async(*args, **kwargs):
-            step = Client().session.active_step
-            if not step:
-                return self.original_create_async(*args, **kwargs)
             description, images = self._format_messages(kwargs.get("messages", []))
             
             event_id = Client().session.create_event(

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/providers/langchain.py

@@ -63,11 +63,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
                 text.append(prompt)
             elif isinstance(prompt, dict) and 'image' in prompt:
                 images.append(prompt['image'])
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
             
         try:
             # Create a new event
@@ -112,12 +107,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
                                 image_url = block.get("image_url", "")
                                 image_str = image_url.get('url', "")
                                 images_b64.append(image_str[image_str.find(',') + 1:])
-
-
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
             
         try:
             # Create a new event
@@ -157,11 +146,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
             message = response.generations[0][0].message
             usage = message.usage_metadata
             cost = calculate_cost(model, usage)
-        
-        # Make sure we have a valid session
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
             
         try:
             if run_str in self.run_to_event:
@@ -206,11 +190,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         logger.debug("Handling LLM error in Langchain Handler, ending event...")
         run_str = str(run_id)
         model = self.run_to_model.get(run_str, "unknown")
-        
-        # Make sure we have a valid session
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
             
         try:
             if run_str in self.run_to_event:
@@ -266,12 +245,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
                                 image_url = block.get("image_url", "")
                                 image_str = image_url.get('url', "")
                                 images_b64.append(image_str[image_str.find(',') + 1:])
-
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
             
         try:
             # Create a new event
@@ -285,11 +258,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         logger.debug("Ending chain execution in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
         
-        # Make sure we have a valid session
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
-        
         # Extract result from outputs
         result = None
         if outputs:
@@ -321,11 +289,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         """Handle chain errors"""
         logger.debug("Handling chain error in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
-        
-        # Make sure we have a valid session
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
             
         try:
             if run_id in self.run_to_event:
@@ -352,11 +315,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         run_id = str(kwargs.get("run_id", "unknown"))
         tool_name = serialized.get("name", "Unknown Tool")
         description = f"Tool Call ({tool_name}): {input_str[:100]}..."
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
             
         try:
             # Create event
@@ -372,11 +330,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         logger.debug("Ending tool execution in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
         
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
-        
         # Get result from output
         result = None
         if output is not None:
@@ -404,11 +357,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         """
         logger.debug("Handling tool error in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
             
         try:
             if run_id in self.run_to_event:
@@ -434,11 +382,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         run_id = str(kwargs.get("run_id", "unknown"))
         retriever_type = serialized.get("name", "Unknown Retriever")
         description = f"Retriever ({retriever_type}): {query[:100]}..."
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
             
         try:
             # Create event
@@ -454,11 +397,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         logger.debug("Ending retriever execution in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
         
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
-        
         # Extract result from documents
         result = None
         if documents:
@@ -493,11 +431,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         """
         logger.debug("Handling retriever error in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
             
         try:
             if run_id in self.run_to_event:
@@ -524,11 +457,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         tool = getattr(action, 'tool', 'unknown_tool')
         description = f"Agent Action: {tool}"
         
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot create event - no active session or step")
-            return
-        
         # Extract useful information from the action
         result = None
         try:
@@ -571,12 +499,6 @@ class LucidicLangchainHandler(BaseCallbackHandler):
         """
         logger.debug("Handling agent finish in Langchain Handler, ending event...")
         run_id = str(kwargs.get("run_id", "unknown"))
-
-        
-        # Make sure we have a valid session and step
-        if not (Client().session and Client().session.active_step):
-            logger.warning("Cannot end event - no active session or step")
-            return
         
         # Extract result from finish
         result = None

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/providers/openai_handler.py

@@ -122,20 +122,7 @@ class OpenAIHandler(BaseProvider):
                 if session is None:
                     logger.info(f"[OpenAI Handler] No session, skipping tracking")
                     return await original_method(*args, **kwargs)
-                
-                # Auto-create step if no active step exists
-                if session.active_step is None:
-                    logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                    try:
-                        step_id = session.create_step(
-                            state="Auto-created step for API call",
-                            action=f"Execute {method_name}",
-                            goal="Process API request"
-                        )
-                        logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                    except Exception as e:
-                        logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                        return await original_method(*args, **kwargs)
+
                 
                 # Prepare kwargs
                 self._prepare_streaming_kwargs(method_name, kwargs)
@@ -157,20 +144,6 @@ class OpenAIHandler(BaseProvider):
                     logger.info(f"[OpenAI Handler] No session, skipping tracking")
                     return original_method(*args, **kwargs)
                 
-                # Auto-create step if no active step exists
-                if session.active_step is None:
-                    logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                    try:
-                        step_id = session.create_step(
-                            state="Auto-created step for API call",
-                            action=f"Execute {method_name}",
-                            goal="Process API request"
-                        )
-                        logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                    except Exception as e:
-                        logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                        return original_method(*args, **kwargs)
-                
                 # Prepare kwargs
                 self._prepare_streaming_kwargs(method_name, kwargs)
                 
@@ -394,20 +367,6 @@ class OpenAIHandler(BaseProvider):
                 logger.info(f"[OpenAI Handler] No session, skipping tracking")
                 return await original_method(*args, **kwargs)
             
-            # Auto-create step if no active step exists
-            if session.active_step is None:
-                logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                try:
-                    step_id = session.create_step(
-                        state="Auto-created step for responses API call",
-                        action="Execute responses.create",
-                        goal="Process API request"
-                    )
-                    logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                except Exception as e:
-                    logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                    return await original_method(*args, **kwargs)
-            
             # Check for agent context
             agent_name = self._get_agent_name_from_input(kwargs.get('input', []))
             
@@ -500,20 +459,6 @@ class OpenAIHandler(BaseProvider):
                 logger.info(f"[OpenAI Handler] No session, skipping tracking")
                 return original_method(*args, **kwargs)
             
-            # Auto-create step if no active step exists
-            if session.active_step is None:
-                logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                try:
-                    step_id = session.create_step(
-                        state="Auto-created step for responses API call",
-                        action="Execute responses.create",
-                        goal="Process API request"
-                    )
-                    logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                except Exception as e:
-                    logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                    return original_method(*args, **kwargs)
-            
             # Check for agent context
             agent_name = self._get_agent_name_from_input(kwargs.get('input', []))
             

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/providers/pydantic_ai_handler.py

@@ -381,11 +381,6 @@ class PydanticAIHandler(BaseProvider):
 
     def _wrap_request(self, model_instance, messages, model_settings, model_request_parameters, original_method):
         """Wrap regular request method to track LLM calls"""
-        # Create event before API call
-        step = Client().session.active_step
-        if step is None:
-            return original_method(model_instance, messages, model_settings, model_request_parameters)
-        
         description = self._format_messages(messages)
         event_id = Client().session.create_event(
             description=description,
@@ -412,13 +407,6 @@ class PydanticAIHandler(BaseProvider):
     
     def _wrap_request_stream_context_manager(self, model_instance, messages, model_settings, model_request_parameters, original_method):
         """Return an async context manager for streaming requests"""
-        # Create event before API call
-        event_id = None
-        step = Client().session.active_step
-        
-        if step is None:
-            return original_method(model_instance, messages, model_settings, model_request_parameters)
-        
         description = self._format_messages(messages)
         event_id = Client().session.create_event(
             description=description,
@@ -466,13 +454,8 @@ class PydanticAIHandler(BaseProvider):
 
     async def _wrap_request_stream(self, model_instance, messages, model_settings, model_request_parameters, original_method):
         """Wrap streaming request method"""
-        # Create event before API call
-        step = Client().session.active_step
-        if step is None:
-            return original_method(model_instance, messages, model_settings, model_request_parameters)
-
         description = self._format_messages(messages)
-        event = step.create_event(
+        event = Client().session.create_event(
             description=description,
             result="Streaming response..."
         )

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/session.py

@@ -43,7 +43,8 @@ class Session:
             "task": kwargs.get("task", None),
             "mass_sim_id": kwargs.get("mass_sim_id", None),
             "rubrics": kwargs.get("rubrics", None),
-            "tags": kwargs.get("tags", None)
+            "tags": kwargs.get("tags", None),
+            "production_monitoring": kwargs.get("production_monitoring", False)
         }
         data = Client().make_request('initsession', 'POST', request_data)
         self.session_id = data["session_id"]
@@ -73,9 +74,9 @@ class Session:
             "is_finished": kwargs.get("is_finished", None),
             "task": kwargs.get("task", None),
             "is_successful": kwargs.get("is_successful", None),
-            "is_successful_reason": kwargs.get("is_successful_reason", None),
+            "is_successful_reason": Client().mask(kwargs.get("is_successful_reason", None)),
             "session_eval": kwargs.get("session_eval", None),
-            "session_eval_reason": kwargs.get("session_eval_reason", None),
+            "session_eval_reason": Client().mask(kwargs.get("session_eval_reason", None)),
             "tags": kwargs.get("tags", None)
         }
         Client().make_request('updatesession', 'PUT', request_data)
@@ -101,12 +102,14 @@ class Session:
 
     def create_event(self, **kwargs):
         # Get step_id from kwargs or active step
+        temp_step_created = False
         if 'step_id' in kwargs and kwargs['step_id'] is not None:
             step_id = kwargs['step_id']
         elif self._active_step:
             step_id = self._active_step
         else:
-            raise InvalidOperationError("No active step to create event in and no step_id provided")
+            step_id = self.create_step()
+            temp_step_created = True
         kwargs.pop('step_id', None)
         event = Event(
             session_id=self.session_id,
@@ -115,6 +118,9 @@ class Session:
         )
         self.event_history[event.event_id] = event
         self._active_event = event
+        if temp_step_created:
+            self.update_step(step_id=step_id, is_finished=True)
+            self._active_step = None
         return event.event_id
 
     def update_event(self, **kwargs):

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/step.py

@@ -48,11 +48,11 @@ class Step:
             upload_image_to_s3(presigned_url, screenshot, "JPEG")
         request_data = {
             "step_id": self.step_id,
-            "goal": kwargs['goal'] if 'goal' in kwargs else None,
-            "action": kwargs['action'] if 'action' in kwargs else None,
-            "state": kwargs['state'] if 'state' in kwargs else None,
+            "goal": Client().mask(kwargs['goal']) if 'goal' in kwargs else None,
+            "action": Client().mask(kwargs['action']) if 'action' in kwargs else None,
+            "state": Client().mask(kwargs['state']) if 'state' in kwargs else None,
             "eval_score": kwargs['eval_score'] if 'eval_score' in kwargs else None,
-            "eval_description": kwargs['eval_description'] if 'eval_description' in kwargs else None,
+            "eval_description": Client().mask(kwargs['eval_description']) if 'eval_description' in kwargs else None,
             "is_finished": kwargs['is_finished'] if 'is_finished' in kwargs else None,
             "has_screenshot": True if screenshot else None
         }

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai/streaming.py

@@ -14,7 +14,6 @@ class StreamingResponseWrapper:
     
     def __init__(self, response: Any, session: Any, kwargs: Dict[str, Any]):
         self.response = response
-        self.session = session
         self.kwargs = kwargs
         self.chunks = []
         self.start_time = time.time()
@@ -34,7 +33,7 @@ class StreamingResponseWrapper:
                 logger.info(f"[Streaming] Using existing event ID: {self.event_id}")
                 return
                 
-            if self.session and hasattr(self.session, 'active_step') and self.session.active_step:
+            if Client().session:
                 description, images = self._format_messages(self.kwargs.get('messages', ''))
                 
                 event_data = {
@@ -54,7 +53,7 @@ class StreamingResponseWrapper:
                 if images:
                     event_data['screenshots'] = images
                 
-                self.event_id = self.session.create_event(**event_data)
+                self.event_id = Client().session.create_event(**event_data)
                 logger.debug(f"[Streaming] Created new streaming event with ID: {self.event_id}")
         except Exception as e:
             logger.error(f"[Streaming] Error creating initial streaming event: {str(e)}")

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 1.2.14
+Version: 1.2.16
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

{lucidicai-1.2.14 → lucidicai-1.2.16}/lucidicai.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ lucidicai/providers/openai_handler.py
 lucidicai/providers/opentelemetry_converter.py
 lucidicai/providers/pydantic_ai_handler.py
 tests/test_anthropic_comprehensive.py
+tests/test_anthropic_thinking.py
 tests/test_event_display.py
 tests/test_openai_agents_9_patterns_fixed.py
 tests/test_openai_comprehensive.py

{lucidicai-1.2.14 → lucidicai-1.2.16}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="lucidicai",
-    version="1.2.14",
+    version="1.2.16",
     packages=find_packages(),
     install_requires=[
         "requests>=2.25.1",

lucidicai-1.2.16/tests/test_anthropic_thinking.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""
+Test script for Lucidic SDK with Anthropic Thinking mode.
+This tests the SDK's ability to handle ThinkingBlock responses from Anthropic.
+
+Required environment variables:
+- ANTHROPIC_API_KEY: Your Anthropic API key
+- LUCIDIC_API_KEY: Your Lucidic API key
+- LUCIDIC_AGENT_ID: Your Lucidic agent ID
+
+You can set these in a .env file or export them in your shell.
+
+Note: Extended thinking is supported in these models:
+- Claude Opus 4 (claude-opus-4-20250514)
+- Claude Sonnet 4 (claude-sonnet-4-20250514)
+- Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)
+
+This test uses Claude 3.7 Sonnet. For Claude 4 models, you can also use
+the beta header "anthropic-beta: interleaved-thinking-2025-05-14" for
+interleaved thinking between tool calls.
+"""
+
+import os
+import asyncio
+from anthropic import Anthropic
+import lucidicai as lai
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def test_anthropic_thinking_sync():
+    """Test synchronous Anthropic calls with thinking mode"""
+    print("Testing Anthropic Thinking mode (synchronous)...")
+    
+    # Create Anthropic client - SDK will automatically handle it with the provider
+    client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+    
+    # Create a step for this test
+    lai.create_step(
+        action="Test Anthropic Thinking Mode",
+        goal="Testing ThinkingBlock handling in Anthropic responses"
+    )
+    
+    try:
+        # Test 1: Simple thinking mode request
+        print("\nTest 1: Simple thinking request...")
+        response = client.messages.create(
+            model="claude-3-7-sonnet-20250219",  # Using Claude 3.7 Sonnet which supports extended thinking
+            max_tokens=4096,
+            messages=[{
+                "role": "user",
+                "content": "Think step by step about how to calculate the factorial of 5."
+            }],
+            thinking={
+                "type": "enabled",
+                "budget_tokens": 2048  # Minimum is 1024
+            }
+        )
+        
+        # Check for thinking blocks in response
+        thinking_content = None
+        text_content = None
+        for block in response.content:
+            if hasattr(block, 'type'):
+                if block.type == 'thinking':
+                    thinking_content = getattr(block, 'thinking', '')
+                    print(f"Thinking block detected: {thinking_content[:100]}...")
+                elif block.type == 'text':
+                    text_content = block.text
+        
+        if text_content:
+            print(f"Response: {text_content[:200]}...")
+        else:
+            print("No text content found in response")
+        
+        # Test 2: Complex reasoning with thinking
+        print("\nTest 2: Complex reasoning with thinking...")
+        response2 = client.messages.create(
+            model="claude-3-7-sonnet-20250219",  # Using Claude 3.7 Sonnet which supports extended thinking
+            max_tokens=5000,
+            messages=[{
+                "role": "user",
+                "content": "Think through this problem: If a train leaves Station A at 2 PM traveling at 60 mph, and another train leaves Station B at 3 PM traveling at 80 mph, and the stations are 280 miles apart, when will they meet?"
+            }],
+            thinking={
+                "type": "enabled",
+                "budget_tokens": 3000
+            }
+        )
+        
+        # Check for thinking blocks in response2
+        for block in response2.content:
+            if hasattr(block, 'type'):
+                if block.type == 'thinking':
+                    print(f"Thinking block detected in response2")
+                elif block.type == 'text':
+                    print(f"Response: {block.text[:200]}...")
+        
+        # Test 3: Multi-turn conversation with thinking
+        print("\nTest 3: Multi-turn conversation with thinking...")
+        messages = [
+            {"role": "user", "content": "Let's solve a logic puzzle. Think through this: Three houses are in a row. The red house is to the left of the green house. The blue house is to the right of the red house. What is the order of the houses?"},
+            {"role": "assistant", "content": "I need to think through this step-by-step.\n\nGiven information:\n- Three houses in a row\n- Red house is to the left of green house\n- Blue house is to the right of red house\n\nFrom 'Red is left of Green': Red < Green\nFrom 'Blue is right of Red': Red < Blue\n\nSo we have: Red < Green and Red < Blue\n\nThis means Red must be the leftmost house. Now I need to determine the order of Blue and Green.\n\nIf the order were Red, Green, Blue, that would satisfy both conditions.\nIf the order were Red, Blue, Green, that would also satisfy both conditions.\n\nWait, let me reconsider. If Blue is to the right of Red, and Red is to the left of Green, we need to check if there's a unique solution.\n\nActually, the order must be: Red, Blue, Green\n\nThis satisfies:\n- Red is to the left of Green ✓\n- Blue is to the right of Red ✓"},
+            {"role": "user", "content": "Think about whether your answer is correct. What if the order was Red, Green, Blue?"}
+        ]
+        
+        response3 = client.messages.create(
+            model="claude-3-7-sonnet-20250219",  # Using Claude 3.7 Sonnet which supports extended thinking
+            max_tokens=4096,
+            messages=messages,
+            thinking={
+                "type": "enabled",
+                "budget_tokens": 2048
+            }
+        )
+        
+        # Check for thinking blocks in response3
+        for block in response3.content:
+            if hasattr(block, 'type'):
+                if block.type == 'thinking':
+                    print(f"Thinking block detected in response3")
+                elif block.type == 'text':
+                    print(f"Response: {block.text[:200]}...")
+        
+        # Update step with results
+        lai.update_step(
+            state="Test completed successfully",
+            action="Ran 3 thinking mode tests",
+            eval_score=1.0,
+            eval_description="All thinking mode tests passed"
+        )
+        
+    except Exception as e:
+        print(f"Error during testing: {e}")
+        lai.update_step(
+            state="Test failed",
+            action="Error during testing",
+            eval_score=0.0,
+            eval_description=f"Error: {str(e)}"
+        )
+        raise
+    
+    finally:
+        lai.end_step()
+        pass
+
+def test_anthropic_thinking_streaming():
+    """Test streaming Anthropic calls with thinking mode"""
+    print("\n\nTesting Anthropic Thinking mode (streaming)...")
+    
+    # Create Anthropic client - SDK will automatically handle it with the provider
+    client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+    
+    # Create a step for this test
+    lai.create_step(
+        action="Test Anthropic Thinking Mode Streaming",
+        goal="Testing ThinkingBlock handling in streaming Anthropic responses"
+    )
+    
+    try:
+        print("\nTest 4: Streaming with thinking mode...")
+        
+        # Create a streaming request
+        stream = client.messages.create(
+            model="claude-3-7-sonnet-20250219",  # Using Claude 3.7 Sonnet which supports extended thinking
+            max_tokens=4096,
+            messages=[{
+                "role": "user",
+                "content": "Think through how to implement a binary search algorithm in Python, then provide the code."
+            }],
+            stream=True,
+            thinking={
+                "type": "enabled",
+                "budget_tokens": 2500
+            }
+        )
+        
+        # Process the stream
+        full_response = ""
+        thinking_blocks = []
+        
+        for chunk in stream:
+            if hasattr(chunk, 'type'):
+                if chunk.type == 'content_block_start':
+                    if hasattr(chunk, 'content_block') and hasattr(chunk.content_block, 'type'):
+                        if chunk.content_block.type == 'thinking':
+                            print('\nThinking block started...', end='', flush=True)
+                elif chunk.type == 'content_block_delta':
+                    if hasattr(chunk.delta, 'text'):
+                        full_response += chunk.delta.text
+                        print('.', end='', flush=True)
+                    elif hasattr(chunk.delta, 'thinking'):
+                        print('T', end='', flush=True)
+                        thinking_blocks.append(chunk)
+        
+        print(f"\n\nStreaming response received ({len(full_response)} chars)")
+        print(f"Thinking blocks detected: {len(thinking_blocks)}")
+        
+        lai.update_step(
+            state="Streaming test completed",
+            action=f"Processed {len(full_response)} chars with {len(thinking_blocks)} thinking blocks",
+            eval_score=1.0,
+            eval_description="Streaming with thinking blocks handled successfully"
+        )
+        
+    except Exception as e:
+        print(f"Error during streaming test: {e}")
+        lai.update_step(
+            state="Streaming test failed",
+            action="Error during streaming test",
+            eval_score=0.0,
+            eval_description=f"Error: {str(e)}"
+        )
+        raise
+    
+    finally:
+        lai.end_step()
+        pass
+
+async def test_anthropic_thinking_async():
+    """Test asynchronous Anthropic calls with thinking mode"""
+    print("\n\nTesting Anthropic Thinking mode (asynchronous)...")
+    
+    from anthropic import AsyncAnthropic
+    
+    # Create async Anthropic client - SDK will automatically handle it with the provider
+    client = AsyncAnthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+    
+    # Create a step for this test
+    lai.create_step(
+        action="Test Anthropic Thinking Mode Async",
+        goal="Testing ThinkingBlock handling in async Anthropic responses"
+    )
+    
+    try:
+        print("\nTest 5: Async thinking mode request...")
+        
+        response = await client.messages.create(
+            model="claude-3-7-sonnet-20250219",  # Using Claude 3.7 Sonnet which supports extended thinking
+            max_tokens=4096,
+            messages=[{
+                "role": "user",
+                "content": "Think about the most efficient sorting algorithm for a nearly sorted array and explain why."
+            }],
+            thinking={
+                "type": "enabled",
+                "budget_tokens": 2048
+            }
+        )
+        
+        # Check for thinking blocks in async response
+        for block in response.content:
+            if hasattr(block, 'type'):
+                if block.type == 'thinking':
+                    print(f"Thinking block detected in async response")
+                elif block.type == 'text':
+                    print(f"Async response: {block.text[:200]}...")
+        
+        lai.update_step(
+            state="Async test completed",
+            action="Executed async thinking mode request",
+            eval_score=1.0,
+            eval_description="Async thinking mode handled successfully"
+        )
+        
+    except Exception as e:
+        print(f"Error during async test: {e}")
+        lai.update_step(
+            state="Async test failed",
+            action="Error during async test",
+            eval_score=0.0,
+            eval_description=f"Error: {str(e)}"
+        )
+        raise
+    
+    finally:
+        lai.end_step()
+        pass
+
+def main():
+    """Run all tests"""
+    print("Starting Lucidic SDK Anthropic Thinking Mode Tests")
+    print("=" * 50)
+    
+    # Check for required environment variables
+    required_vars = ["ANTHROPIC_API_KEY", "LUCIDIC_API_KEY", "LUCIDIC_AGENT_ID"]
+    missing_vars = [var for var in required_vars if not os.environ.get(var)]
+    
+    if missing_vars:
+        print("Error: Missing required environment variables:")
+        for var in missing_vars:
+            print(f"  - {var}")
+        print("\nPlease set these environment variables or add them to a .env file.")
+        return
+    
+    # Initialize the SDK with Anthropic provider
+    session_id = lai.init(
+        session_name="Anthropic Thinking Mode Test",
+        providers=["anthropic"]
+    )
+    print(f"Session initialized: {session_id}")
+    
+    try:
+        # Run synchronous tests
+        test_anthropic_thinking_sync()
+        
+        # Run streaming tests
+        test_anthropic_thinking_streaming()
+        
+        # Run async tests
+        asyncio.run(test_anthropic_thinking_async())
+        
+        print("\n\nAll tests completed successfully!")
+        
+    except Exception as e:
+        print(f"\n\nTest suite failed: {e}")
+        raise
+    
+    finally:
+        # End the session
+        lai.end_session()
+        print("\nSession ended.")
+
+if __name__ == "__main__":
+    main()