crewplus 0.2.43__tar.gz → 0.2.46__tar.gz

{crewplus-0.2.43 → crewplus-0.2.46}/PKG-INFO

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

crewplus-0.2.46/crewplus/callbacks/async_langfuse_handler.py

@@ -0,0 +1,162 @@
+# File: crewplus/callbacks/async_langfuse_handler.py
+import asyncio
+import contextvars
+from contextlib import contextmanager
+from typing import Any, Dict, List, Union, Optional, Sequence
+from uuid import UUID
+
+try:
+    from langfuse.langchain import CallbackHandler as LangfuseCallbackHandler
+    from langchain_core.callbacks import AsyncCallbackHandler
+    from langchain_core.outputs import LLMResult, ChatGeneration
+    from langchain_core.messages import BaseMessage
+    from langchain.schema.agent import AgentAction, AgentFinish
+    from langchain.schema.document import Document
+    LANGFUSE_AVAILABLE = True
+except ImportError:
+    LANGFUSE_AVAILABLE = False
+    LangfuseCallbackHandler = None
+    AsyncCallbackHandler = object
+    # Define dummy types if langchain is not available
+    LLMResult = object
+    BaseMessage = object
+    AgentAction = object
+    AgentFinish = object
+    Document = object
+
+
+_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 fully compatible with
+    LangChain's async methods by handling all relevant events.
+    """
+    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:
+        return getattr(self.sync_handler, name)
+
+    # LLM Events
+    async def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        corrected_prompts = prompts if isinstance(prompts, list) else [prompts]
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_start, serialized, corrected_prompts, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_chat_model_start(
+        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chat_model_start, serialized, messages, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_llm_end(
+        self, response: LLMResult, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_end, response, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> None:
+        await asyncio.to_thread(
+            self.sync_handler.on_llm_error, error, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    # Chain Events
+    async def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_start, serialized, inputs, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_chain_end(
+        self, outputs: Dict[str, Any], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_end, outputs, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_chain_error(
+        self, error: Union[Exception, KeyboardInterrupt], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_chain_error, error, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    # Tool Events
+    async def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_start, serialized, input_str, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_tool_end(
+        self, output: str, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_end, output, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_tool_error, error, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+        
+    # Retriever Events
+    async def on_retriever_start(
+        self, serialized: Dict[str, Any], query: str, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_retriever_start, serialized, query, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_retriever_end(
+        self, documents: Sequence[Document], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_retriever_end, documents, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_retriever_error(
+        self, error: Union[Exception, KeyboardInterrupt], *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_retriever_error, error, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+        
+    # Agent Events
+    async def on_agent_action(
+        self, action: AgentAction, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_agent_action, action, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )
+
+    async def on_agent_finish(
+        self, finish: AgentFinish, *, run_id: UUID, parent_run_id: Optional[UUID] = None, **kwargs: Any
+    ) -> Any:
+        await asyncio.to_thread(
+            self.sync_handler.on_agent_finish, finish, run_id=run_id, parent_run_id=parent_run_id, **kwargs
+        )

{crewplus-0.2.43 → crewplus-0.2.46}/pyproject.toml

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

crewplus-0.2.43/crewplus/callbacks/async_langfuse_handler.py

@@ -1,107 +0,0 @@
-# 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:
-        # --- DEBUGGING: Inspect the arguments from LangChain ---
-        print("--- [DEBUG] AsyncLangfuseCallbackHandler.on_llm_start ---")
-        print(f"Received prompts type: {type(prompts)}")
-        print(f"Received prompts value: {prompts!r}") # Using !r to see quotes if it's a string
-        print("----------------------------------------------------------")
-        # --- END DEBUGGING ---
-
-        # 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
-        )