prefactor-langchain 0.2.4__tar.gz → 0.2.7__tar.gz

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/.gitignore

@@ -41,7 +41,6 @@ env/
 
 # uv
 .uv/
-uv.lock
 
 # Type checkers
 .mypy_cache/
@@ -70,3 +69,4 @@ htmlcov/
 .env
 mise.local.toml
 prefactor.json
+.worktrees/

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: prefactor-langchain
-Version: 0.2.4
+Version: 0.2.7
 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.2.2
+Requires-Dist: prefactor-core>=0.5.1
 Description-Content-Type: text/markdown
 
 # prefactor-langchain
@@ -27,9 +27,9 @@ pip install prefactor-langchain
 from prefactor_langchain import LangChainToolSchemaConfig, PrefactorMiddleware
 
 middleware = PrefactorMiddleware.from_config(
-    api_url="https://api.prefactor.ai",
+    api_url="https://app.prefactorai.com",
     api_token="your-api-token",
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     agent_name="My Agent",  # optional
     tool_schemas={
         "send_email": LangChainToolSchemaConfig(
@@ -59,6 +59,9 @@ result = agent.invoke({"messages": [...]})
 await middleware.close()
 ```
 
+With a deployment-scoped token you can omit `agent_id`; the backend derives the
+agent and environment from the token during registration.
+
 ### Pre-configured client
 
 Pass a client you created yourself when you need full control over its
@@ -69,14 +72,16 @@ from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
 from prefactor_http.config import HttpClientConfig
 from prefactor_langchain import PrefactorMiddleware
 
-http_config = HttpClientConfig(api_url="https://api.prefactor.ai", api_token="your-api-token")
+http_config = HttpClientConfig(
+    api_url="https://app.prefactorai.com", api_token="your-api-token"
+)
 config = PrefactorCoreConfig(http_config=http_config)
 client = PrefactorCoreClient(config)
 await client.initialize()
 
 middleware = PrefactorMiddleware(
     client=client,
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     agent_name="My Agent",
 )
 
@@ -121,9 +126,9 @@ register_langchain_schemas(
 )
 
 middleware = PrefactorMiddleware.from_config(
-    api_url="https://api.prefactor.ai",
+    api_url="https://app.prefactorai.com",
     api_token="your-api-token",
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     schema_registry=registry,
 )
 ```
@@ -140,7 +145,9 @@ from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
 from prefactor_http.config import HttpClientConfig
 from prefactor_langchain import PrefactorMiddleware
 
-http_config = HttpClientConfig(api_url="https://api.prefactor.ai", api_token="your-api-token")
+http_config = HttpClientConfig(
+    api_url="https://app.prefactorai.com", api_token="your-api-token"
+)
 config = PrefactorCoreConfig(http_config=http_config)
 client = PrefactorCoreClient(config)
 await client.initialize()

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/README.md

@@ -16,9 +16,9 @@ pip install prefactor-langchain
 from prefactor_langchain import LangChainToolSchemaConfig, PrefactorMiddleware
 
 middleware = PrefactorMiddleware.from_config(
-    api_url="https://api.prefactor.ai",
+    api_url="https://app.prefactorai.com",
     api_token="your-api-token",
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     agent_name="My Agent",  # optional
     tool_schemas={
         "send_email": LangChainToolSchemaConfig(
@@ -48,6 +48,9 @@ result = agent.invoke({"messages": [...]})
 await middleware.close()
 ```
 
+With a deployment-scoped token you can omit `agent_id`; the backend derives the
+agent and environment from the token during registration.
+
 ### Pre-configured client
 
 Pass a client you created yourself when you need full control over its
@@ -58,14 +61,16 @@ from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
 from prefactor_http.config import HttpClientConfig
 from prefactor_langchain import PrefactorMiddleware
 
-http_config = HttpClientConfig(api_url="https://api.prefactor.ai", api_token="your-api-token")
+http_config = HttpClientConfig(
+    api_url="https://app.prefactorai.com", api_token="your-api-token"
+)
 config = PrefactorCoreConfig(http_config=http_config)
 client = PrefactorCoreClient(config)
 await client.initialize()
 
 middleware = PrefactorMiddleware(
     client=client,
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     agent_name="My Agent",
 )
 
@@ -110,9 +115,9 @@ register_langchain_schemas(
 )
 
 middleware = PrefactorMiddleware.from_config(
-    api_url="https://api.prefactor.ai",
+    api_url="https://app.prefactorai.com",
     api_token="your-api-token",
-    agent_id="my-agent",
+    agent_id="my-agent",  # Optional for deployment-scoped tokens
     schema_registry=registry,
 )
 ```
@@ -129,7 +134,9 @@ from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
 from prefactor_http.config import HttpClientConfig
 from prefactor_langchain import PrefactorMiddleware
 
-http_config = HttpClientConfig(api_url="https://api.prefactor.ai", api_token="your-api-token")
+http_config = HttpClientConfig(
+    api_url="https://app.prefactorai.com", api_token="your-api-token"
+)
 config = PrefactorCoreConfig(http_config=http_config)
 client = PrefactorCoreClient(config)
 await client.initialize()

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/examples/README.md

@@ -36,7 +36,7 @@ pip install prefactor-langchain langchain
 
 ```bash
 export ANTHROPIC_API_KEY=your_api_key_here
-export PREFACTOR_API_URL=https://api.prefactor.ai
+export PREFACTOR_API_URL=https://app.prefactorai.com
 export PREFACTOR_API_TOKEN=your_token_here
 ```
 

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/examples/simple_agent.py

@@ -17,7 +17,7 @@ Prerequisites:
 
 Example:
     export ANTHROPIC_API_KEY=sk-ant-...
-    export PREFACTOR_API_URL=https://api.prefactor.ai
+    export PREFACTOR_API_URL=https://app.prefactorai.com
     export PREFACTOR_API_TOKEN=your_token
     python simple_agent.py
 """
@@ -27,6 +27,7 @@ import asyncio
 import operator
 import os
 from datetime import datetime
+from typing import Callable
 
 from langchain.agents import create_agent
 from langchain_core.tools import tool
@@ -38,7 +39,7 @@ from prefactor_langchain import PrefactorMiddleware
 # ---------------------------------------------------------------------------
 
 
-_OPS = {
+_OPS: dict[type[ast.operator], Callable[[float, float], float]] = {
     ast.Add: operator.add,
     ast.Sub: operator.sub,
     ast.Mult: operator.mul,
@@ -48,9 +49,14 @@ _OPS = {
 
 def _safe_eval(node: ast.expr) -> float:
     if isinstance(node, ast.Constant):
-        return node.n  # type: ignore[return-value]
+        if isinstance(node.value, (int, float)) and not isinstance(node.value, bool):
+            return float(node.value)
+        raise ValueError(f"Unsupported constant: {node.value!r}")
     if isinstance(node, ast.BinOp):
-        return _OPS[type(node.op)](_safe_eval(node.left), _safe_eval(node.right))  # type: ignore[invalid-argument-type]
+        op_type = type(node.op)
+        if op_type in _OPS:
+            return _OPS[op_type](_safe_eval(node.left), _safe_eval(node.right))
+        raise ValueError(f"Unsupported operator: {ast.dump(node.op)}")
     if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
         return -_safe_eval(node.operand)
     raise ValueError(f"Unsupported expression: {ast.dump(node)}")
@@ -190,7 +196,7 @@ async def main_async():
             "Get your API key from: https://console.anthropic.com/"
         )
 
-    api_url = os.getenv("PREFACTOR_API_URL", "https://api.prefactor.ai")
+    api_url = os.getenv("PREFACTOR_API_URL", "https://app.prefactorai.com")
     api_token = os.getenv("PREFACTOR_API_TOKEN")
     if not api_token:
         raise ValueError(

prefactor_langchain-0.2.7/examples/termination_demo.py

@@ -0,0 +1,203 @@
+"""Termination demo — runs a LangChain agent in a service loop and demonstrates
+automatic detection of p2-initiated termination.
+
+Required env vars:
+    PREFACTOR_API_URL       e.g. http://localhost:4000
+    PREFACTOR_AGENT_ID      agent ID on the target p2 instance
+    PREFACTOR_API_TOKEN     deployment/BA token for SDK (span creation etc.)
+    PREFACTOR_BA_TOKEN      BA token for terminate API (falls back to
+                            PREFACTOR_API_TOKEN)
+
+Optional env vars:
+    PREFACTOR_AUTO_TERMINATE_DELAY  seconds before demo calls terminate API (default: 6)
+    PREFACTOR_RESTART_DELAY         seconds to wait between runs (default: 75)
+
+Usage:
+    PREFACTOR_API_URL=http://localhost:4000 \\
+        PREFACTOR_AGENT_ID=<agent-id> \\
+        PREFACTOR_API_TOKEN=<token> \\
+        PREFACTOR_AUTO_TERMINATE_DELAY=6 \\
+        PREFACTOR_RESTART_DELAY=75 \\
+        python packages/langchain/examples/termination_demo.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+import aiohttp
+from langchain.agents import create_agent
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from prefactor_core import PrefactorTerminatedError
+from prefactor_langchain.middleware import PrefactorMiddleware
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s"
+)
+logger = logging.getLogger("termination-demo")
+
+
+@tool
+def get_current_time() -> str:
+    """Return the current UTC time as a string."""
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).isoformat()
+
+
+async def terminate_after_delay(
+    api_url: str,
+    ba_token: str,
+    instance_id: str,
+    delay: float,
+) -> None:
+    """Call the terminate endpoint after a configured delay.
+
+    Args:
+        api_url: Base Prefactor API URL.
+        ba_token: Bearer token for terminate API authorization.
+        instance_id: Agent instance identifier to terminate.
+        delay: Seconds to wait before posting the terminate request.
+
+    Returns:
+        None.
+
+    Raises:
+        aiohttp.ClientResponseError: If the terminate API returns a non-2xx
+            response.
+        aiohttp.ClientError: If the terminate request fails before a response.
+    """
+    await asyncio.sleep(delay)
+    url = f"{api_url.rstrip('/')}/api/v1/agent_instance/{instance_id}/terminate"
+    logger.info("Calling terminate API: POST %s", url)
+    timeout = aiohttp.ClientTimeout(total=10)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.post(
+            url,
+            headers={
+                "Authorization": f"Bearer {ba_token}",
+                "Content-Type": "application/json",
+            },
+            json={"reason": "demo termination"},
+        ) as resp:
+            body = await resp.text()
+            logger.info("Terminate API: status=%s body=%s", resp.status, body)
+            resp.raise_for_status()
+
+
+async def _cancel_and_await_terminate_task(task: asyncio.Task[None]) -> None:
+    if not task.done():
+        task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    except Exception:
+        logger.exception("Auto-terminate task failed")
+        raise
+
+
+async def run_once(
+    run_number: int,
+    api_url: str,
+    api_token: str,
+    agent_id: str,
+    auto_terminate_delay: float,
+) -> None:
+    """Run one termination-demo agent session.
+
+    Args:
+        run_number: Sequential run counter used in log messages.
+        api_url: Base Prefactor API URL.
+        api_token: SDK API token for Prefactor telemetry.
+        agent_id: Agent identifier used to initialize the middleware.
+        auto_terminate_delay: Seconds before the demo calls the terminate API.
+
+    Returns:
+        None.
+
+    Raises:
+        PrefactorTerminatedError: If Prefactor signals agent termination.
+        Exception: If agent invocation, termination cleanup, or middleware
+            cleanup fails.
+    """
+    environment_id = os.environ.get("PREFACTOR_ENVIRONMENT_ID")
+    middleware = PrefactorMiddleware.from_config(
+        api_url=api_url,
+        api_token=api_token,
+        agent_id=agent_id,
+        agent_name="termination-demo-agent",
+        environment_id=environment_id,
+    )
+
+    model = ChatAnthropic(model_name="claude-haiku-4-5-20251001")
+    agent = create_agent(
+        model, tools=[get_current_time], middleware=[middleware], checkpointer=None
+    )
+
+    instance = await middleware.ensure_initialized()
+    logger.info("Run #%d — Agent instance: %s", run_number, instance.id)
+    logger.info("Auto-terminate in %.0fs...", auto_terminate_delay)
+
+    ba_token = os.environ.get("PREFACTOR_BA_TOKEN", api_token)
+    terminate_task = asyncio.create_task(
+        terminate_after_delay(api_url, ba_token, instance.id, auto_terminate_delay)
+    )
+
+    try:
+        result = await agent.ainvoke(
+            {
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "What time is it? Then keep asking every 2 seconds.",
+                    }
+                ]
+            },
+        )
+        logger.info("Run #%d completed normally: %s", run_number, result)
+    except PrefactorTerminatedError as e:
+        logger.info("Run #%d terminated: %s", run_number, e)
+        raise
+    finally:
+        try:
+            await _cancel_and_await_terminate_task(terminate_task)
+        finally:
+            await middleware.close()
+
+
+async def main() -> None:
+    """Run the termination demo restart loop.
+
+    Returns:
+        None.
+    """
+    api_url = os.environ["PREFACTOR_API_URL"]
+    api_token = os.environ["PREFACTOR_API_TOKEN"]
+    agent_id = os.environ["PREFACTOR_AGENT_ID"]
+    auto_terminate_delay = float(os.environ.get("PREFACTOR_AUTO_TERMINATE_DELAY", "6"))
+    restart_delay = float(os.environ.get("PREFACTOR_RESTART_DELAY", "75"))
+
+    run_number = 0
+    while True:
+        run_number += 1
+        try:
+            await run_once(
+                run_number, api_url, api_token, agent_id, auto_terminate_delay
+            )
+        except PrefactorTerminatedError:
+            logger.info("Service continues — next run in %.0fs.", restart_delay)
+            await asyncio.sleep(restart_delay)
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            logger.info("Stopped by user.")
+            break
+        except Exception as e:
+            logger.exception("Unexpected error in run #%d: %s", run_number, e)
+            await asyncio.sleep(restart_delay)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prefactor-langchain"
-version = "0.2.4"
+dynamic = ["version"]
 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.2.2",
+    "prefactor-core>=0.5.1",
     "langchain-core>=1.0.0",
 ]
 
@@ -17,5 +17,8 @@ dependencies = [
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.version]
+path = "src/prefactor_langchain/_version.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/prefactor_langchain"]

{prefactor_langchain-0.2.4 → prefactor_langchain-0.2.7}/src/prefactor_langchain/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from prefactor_langchain._version import __version__
 from prefactor_langchain.metadata_extractor import (
     extract_error_info,
     extract_token_usage,
@@ -25,8 +26,6 @@ from prefactor_langchain.spans import (
     ToolSpan,
 )
 
-__version__ = "0.2.4"
-
 __all__ = [
     # Middleware
     "PrefactorMiddleware",
@@ -48,4 +47,5 @@ __all__ = [
     "ToolSpan",
     "TokenUsage",
     "ErrorInfo",
+    "__version__",
 ]

prefactor_langchain-0.2.7/src/prefactor_langchain/_version.py

@@ -0,0 +1,5 @@
+"""Package version for prefactor-langchain."""
+
+PACKAGE_NAME = "prefactor-langchain"
+__version__ = "0.2.7"
+PACKAGE_VERSION = __version__