prefactor-langchain 0.2.0__tar.gz → 0.2.2__tar.gz

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: prefactor-langchain
-Version: 0.2.0
+Version: 0.2.2
 Summary: LangChain integration for Prefactor observability
 Author-email: Prefactor Pty Ltd <josh@prefactor.tech>
 License: MIT
 Requires-Python: <4.0.0,>=3.11.0
 Requires-Dist: langchain-core>=1.0.0
-Requires-Dist: prefactor-core>=0.1.0
+Requires-Dist: prefactor-core>=0.2.1
 Description-Content-Type: text/markdown
 
 # prefactor-langchain

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/examples/simple_agent.py

@@ -22,7 +22,9 @@ Example:
     python simple_agent.py
 """
 
+import ast
 import asyncio
+import operator
 import os
 from datetime import datetime
 
@@ -36,11 +38,29 @@ from prefactor_langchain import PrefactorMiddleware
 # ---------------------------------------------------------------------------
 
 
+_OPS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+}
+
+
+def _safe_eval(node: ast.expr) -> float:
+    if isinstance(node, ast.Constant):
+        return node.n  # type: ignore[return-value]
+    if isinstance(node, ast.BinOp):
+        return _OPS[type(node.op)](_safe_eval(node.left), _safe_eval(node.right))
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+        return -_safe_eval(node.operand)
+    raise ValueError(f"Unsupported expression: {ast.dump(node)}")
+
+
 @tool
 def calculator(expression: str) -> str:
-    """Evaluate a mathematical expression."""
+    """Evaluate a mathematical expression safely."""
     try:
-        result = eval(expression)  # noqa: S307
+        result = _safe_eval(ast.parse(expression, mode="eval").body)
         return f"Result: {result}"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -100,7 +120,7 @@ async def run_agent_step(
     SpanContextStack propagates correctly so langchain:agent is automatically
     parented to workflow:agent_step.
     """
-    instance = await middleware._ensure_initialized()
+    instance = await middleware.ensure_initialized()
 
     async with instance.span("workflow:agent_step") as ctx:
         await ctx.start({"message_count": len(messages)})
@@ -136,7 +156,7 @@ async def run_workflow(
               langchain:tool  (if the agent calls a tool)
           workflow:post_process
     """
-    instance = await middleware._ensure_initialized()
+    instance = await middleware.ensure_initialized()
 
     async with instance.span("workflow:run") as root:
         await root.start({"label": label, "query": query})

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prefactor-langchain"
-version = "0.2.0"
+version = "0.2.2"
 description = "LangChain integration for Prefactor observability"
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,7 +9,7 @@ authors = [
 ]
 requires-python = ">=3.11.0, <4.0.0"
 dependencies = [
-    "prefactor-core>=0.1.0",
+    "prefactor-core>=0.2.1",
     "langchain-core>=1.0.0",
 ]
 

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/src/prefactor_langchain/__init__.py

@@ -20,7 +20,7 @@ from prefactor_langchain.spans import (
     ToolSpan,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     # Middleware

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/src/prefactor_langchain/middleware.py

@@ -274,7 +274,7 @@ class PrefactorMiddleware(AgentMiddleware):
         # Derive a stable schema version ID from the registry + agent_name so
         # that the same configuration always maps to the same version
         # (idempotent across runs) and any change produces a new, distinct ID.
-        agent_version_name = "langchain-agent"
+        agent_version_name = self._agent_name or "langchain-agent"
         schema_version_id = f"langchain-{self._agent_id}"
         if self._client._config.schema_registry is not None:
             raw = self._client._config.schema_registry.to_agent_schema_version(
@@ -303,6 +303,10 @@ class PrefactorMiddleware(AgentMiddleware):
         logger.debug("Initialized agent instance %s", self._instance.id)
         return self._instance
 
+    async def ensure_initialized(self) -> AgentInstanceHandle:
+        """Initialize the middleware and return the agent instance handle."""
+        return await self._ensure_initialized()
+
     async def close(self) -> None:
         """Close the middleware and cleanup resources.
 
@@ -580,6 +584,7 @@ class PrefactorMiddleware(AgentMiddleware):
         def _schedule() -> None:
             task = loop.create_task(_emit())
             pending.append(task)
+            task.add_done_callback(pending.remove)
 
         loop.call_soon_threadsafe(_schedule)
 

{prefactor_langchain-0.2.0 → prefactor_langchain-0.2.2}/src/prefactor_langchain/spans.py

@@ -10,7 +10,7 @@ automatically, so they are not included in these span definitions.
 
 import traceback
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Literal, Optional
 
 
@@ -63,7 +63,9 @@ class LangChainSpan:
     """
 
     name: str = "unnamed"
-    start_time: float = field(default_factory=lambda: datetime.now().timestamp())
+    start_time: float = field(
+        default_factory=lambda: datetime.now(timezone.utc).timestamp()
+    )
     end_time: Optional[float] = None
     status: Literal["pending", "running", "completed", "failed"] = "pending"
     inputs: dict[str, Any] = field(default_factory=dict)
@@ -75,14 +77,14 @@ class LangChainSpan:
     def complete(self, outputs: Optional[dict[str, Any]] = None) -> None:
         """Mark the span as completed with outputs."""
         self.status = "completed"
-        self.end_time = datetime.now().timestamp()
+        self.end_time = datetime.now(timezone.utc).timestamp()
         if outputs:
             self.outputs = outputs
 
     def fail(self, error: Exception) -> None:
         """Mark the span as failed with error information."""
         self.status = "failed"
-        self.end_time = datetime.now().timestamp()
+        self.end_time = datetime.now(timezone.utc).timestamp()
         self.error = ErrorInfo(
             error_type=type(error).__name__,
             message=str(error),