crewplus 0.2.40__tar.gz → 0.2.42__tar.gz

{crewplus-0.2.40 → crewplus-0.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.2.40
+Version: 0.2.42
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT

crewplus-0.2.42/crewplus/callbacks/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'callbacks' directory a Python package.

crewplus-0.2.42/crewplus/callbacks/async_langfuse_handler.py

@@ -0,0 +1,99 @@
+# File: crewplus/callbacks/async_langfuse_handler.py
+import asyncio
+import contextvars
+from contextlib import contextmanager
+from typing import Any, Dict, List, Union
+
+try:
+    from langfuse.langchain import CallbackHandler as LangfuseCallbackHandler
+    from langchain_core.callbacks import AsyncCallbackHandler
+    from langchain_core.outputs import LLMResult
+    LANGFUSE_AVAILABLE = True
+except ImportError:
+    LANGFUSE_AVAILABLE = False
+    LangfuseCallbackHandler = None
+    AsyncCallbackHandler = object
+
+# This token is a simple flag to indicate that we are in an async context.
+# We use a context variable to make it available only within the async task.
+_ASYNC_CONTEXT_TOKEN = "in_async_context"
+in_async_context = contextvars.ContextVar(_ASYNC_CONTEXT_TOKEN, default=False)
+
+@contextmanager
+def async_context():
+    """A context manager to signal that we are in an async execution context."""
+    token = in_async_context.set(True)
+    try:
+        yield
+    finally:
+        in_async_context.reset(token)
+
+class AsyncLangfuseCallbackHandler(AsyncCallbackHandler):
+    """
+    Wraps the synchronous LangfuseCallbackHandler to make it compatible with
+    LangChain's async methods.
+    
+    This works by running the synchronous handler's methods in a separate thread
+    using `asyncio.to_thread`. This is crucial because `asyncio`'s default
+    executor can correctly propagate `contextvars`, which solves the
+    `ValueError: <Token ...> was created in a different Context` from OpenTelemetry.
+    """
+    def __init__(self, *args: Any, **kwargs: Any):
+        if not LANGFUSE_AVAILABLE:
+            raise ImportError("Langfuse is not available. Please install it with 'pip install langfuse'")
+        self.sync_handler = LangfuseCallbackHandler(*args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        # Delegate any other attribute access to the sync handler
+        return getattr(self.sync_handler, name)
+
+    async def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        # WORKAROUND: LangChain's async implementation can sometimes pass a raw
+        # string for prompts instead of a list. We wrap it in a list to ensure
+        # compatibility with the synchronous handler.
+        corrected_prompts = prompts if isinstance(prompts, list) else [prompts]
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_start, serialized, corrected_prompts, **kwargs
+        )
+
+    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_end, response, **kwargs
+        )
+    
+    async def on_llm_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> None:
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_error, error, **kwargs
+        )
+    
+    async def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_start, serialized, input_str, **kwargs
+        )
+
+    async def on_tool_end(self, output: str, **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_end, output, **kwargs
+        )
+
+    async def on_tool_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_error, error, **kwargs
+        )
+
+    async def on_chain_start(self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_start, serialized, inputs, **kwargs
+        )
+
+    async def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_end, outputs, **kwargs
+        )
+
+    async def on_chain_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_error, error, **kwargs
+        )

{crewplus-0.2.40 → crewplus-0.2.42}/crewplus/services/azure_chat_model.py

@@ -5,6 +5,7 @@ from typing import Any, Optional
 from langchain_openai.chat_models.azure import AzureChatOpenAI
 from pydantic import Field
 from .tracing_manager import TracingManager, TracingContext
+from ..callbacks.async_langfuse_handler import async_context
 
 class TracedAzureChatOpenAI(AzureChatOpenAI):
     """
@@ -106,8 +107,9 @@ class TracedAzureChatOpenAI(AzureChatOpenAI):
         return super().invoke(input, config=config, **kwargs)
 
     async def ainvoke(self, input, config=None, **kwargs):
-        config = self._tracing_manager.add_callbacks_to_config(config)
-        return await super().ainvoke(input, config=config, **kwargs)
+        with async_context():
+            config = self._tracing_manager.add_callbacks_to_config(config)
+            return await super().ainvoke(input, config=config, **kwargs)
 
     def stream(self, input, config=None, **kwargs):
         # Add stream_options to get usage data for Langfuse
@@ -124,6 +126,7 @@ class TracedAzureChatOpenAI(AzureChatOpenAI):
         stream_options["include_usage"] = True
         kwargs["stream_options"] = stream_options
         
-        config = self._tracing_manager.add_callbacks_to_config(config)
-        async for chunk in super().astream(input, config=config, **kwargs):
-            yield chunk
+        with async_context():
+            config = self._tracing_manager.add_callbacks_to_config(config)
+            async for chunk in super().astream(input, config=config, **kwargs):
+                yield chunk

{crewplus-0.2.40 → crewplus-0.2.42}/crewplus/services/tracing_manager.py

@@ -8,10 +8,13 @@ import logging
 # even if the langfuse library is not installed.
 try:
     from langfuse.langchain import CallbackHandler as LangfuseCallbackHandler
+    from ..callbacks.async_langfuse_handler import AsyncLangfuseCallbackHandler, in_async_context
     LANGFUSE_AVAILABLE = True
 except ImportError:
     LANGFUSE_AVAILABLE = False
     LangfuseCallbackHandler = None
+    AsyncLangfuseCallbackHandler = None
+    in_async_context = None
 
 class TracingContext(Protocol):
     """
@@ -65,7 +68,8 @@ class TracingManager:
                      to the TracingContext protocol.
         """
         self.context = context
-        self._handlers: List[Any] = []
+        self._sync_handlers: List[Any] = []
+        self._async_handlers: List[Any] = []
         self._initialize_handlers()
     
     def _initialize_handlers(self):
@@ -73,7 +77,8 @@ class TracingManager:
         Initializes all supported tracing handlers. This is the central point
         for adding new observability tools.
         """
-        self._handlers = []
+        self._sync_handlers = []
+        self._async_handlers = []
         self._initialize_langfuse()
         # To add a new handler (e.g., Helicone), you would add a call to
         # self._initialize_helicone() here.
@@ -94,8 +99,14 @@ class TracingManager:
         
         if enable_langfuse:
             try:
-                handler = LangfuseCallbackHandler()
-                self._handlers.append(handler)
+                # Create both sync and async handlers. We'll pick one at runtime.
+                sync_handler = LangfuseCallbackHandler()
+                self._sync_handlers.append(sync_handler)
+
+                if AsyncLangfuseCallbackHandler:
+                    async_handler = AsyncLangfuseCallbackHandler()
+                    self._async_handlers.append(async_handler)
+                
                 self.context.logger.info(f"Langfuse tracing enabled for {self.context.get_model_identifier()}")
             except Exception as e:
                 self.context.logger.warning(f"Failed to initialize Langfuse: {e}")
@@ -118,15 +129,19 @@ class TracingManager:
         if config is None:
             config = {}
         
+        # Decide which handlers to use based on the async context flag.
+        is_async = in_async_context.get() if in_async_context else False
+        handlers = self._async_handlers if is_async else self._sync_handlers
+
         # Respect a global disable flag for this specific call.
-        if not self._handlers or config.get("metadata", {}).get("tracing_disabled"):
+        if not handlers or config.get("metadata", {}).get("tracing_disabled"):
             return config
         
         callbacks = config.get("callbacks")
         
         # Case 1: The 'callbacks' key holds a CallbackManager instance
         if hasattr(callbacks, 'add_handler') and hasattr(callbacks, 'handlers'):
-            for handler in self._handlers:
+            for handler in handlers:
                 if not any(isinstance(cb, type(handler)) for cb in callbacks.handlers):
                     callbacks.add_handler(handler, inherit=True)
             return config # Return the original, now-mutated config
@@ -135,7 +150,7 @@ class TracingManager:
         current_callbacks = callbacks or []
         new_callbacks = list(current_callbacks)
         
-        for handler in self._handlers:
+        for handler in handlers:
             if not any(isinstance(cb, type(handler)) for cb in new_callbacks):
                 new_callbacks.append(handler)
         

{crewplus-0.2.40 → crewplus-0.2.42}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "crewplus"
-version = "0.2.40"
+version = "0.2.42"
 description = "Base services for CrewPlus AI applications"
 authors = [
     { name = "Tim Liu", email = "tim@opsmateai.com" },