prefactor-core 0.2.3__tar.gz → 0.2.4__tar.gz

{prefactor_core-0.2.3 → prefactor_core-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefactor-core
-Version: 0.2.3
+Version: 0.2.4
 Summary: Core Prefactor SDK with async queue-based operations
 Author-email: Prefactor Pty Ltd <josh@prefactor.tech>
 License: MIT

{prefactor_core-0.2.3 → prefactor_core-0.2.4}/src/prefactor_core/_version.py

@@ -3,5 +3,5 @@
 from __future__ import annotations
 
 PACKAGE_NAME = "prefactor-core"
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 PACKAGE_VERSION = __version__

{prefactor_core-0.2.3 → prefactor_core-0.2.4}/src/prefactor_core/client.py

@@ -274,6 +274,7 @@ class PrefactorCoreClient:
             elif operation.type == OperationType.FINISH_AGENT_INSTANCE:
                 await self._http.agent_instances.finish(
                     agent_instance_id=operation.payload["instance_id"],
+                    status=operation.payload.get("status", "complete"),
                     timestamp=operation.timestamp,
                     idempotency_key=operation.payload.get("idempotency_key"),
                 )

{prefactor_core-0.2.3 → prefactor_core-0.2.4}/src/prefactor_core/managers/agent_instance.py

@@ -14,6 +14,7 @@ from ..utils import generate_idempotency_key
 
 if TYPE_CHECKING:
     from prefactor_http.client import PrefactorHttpClient
+    from prefactor_http.models.types import FinishStatus
 
     from ..client import PrefactorCoreClient
 
@@ -115,20 +116,30 @@ class AgentInstanceManager:
 
         await self._enqueue(operation)
 
-    async def finish(self, instance_id: str) -> None:
+    async def finish(
+        self,
+        instance_id: str,
+        status: "FinishStatus" = "complete",
+    ) -> None:
         """Mark an instance as finished.
 
         Queues a finish operation for the instance.
 
         Args:
             instance_id: The ID of the instance to finish.
+            status: Terminal status for the instance. Defaults to ``"complete"``.
         """
-        await self.finish_with_idempotency_key(instance_id, generate_idempotency_key())
+        await self.finish_with_idempotency_key(
+            instance_id,
+            generate_idempotency_key(),
+            status=status,
+        )
 
     async def finish_with_idempotency_key(
         self,
         instance_id: str,
         idempotency_key: str,
+        status: "FinishStatus" = "complete",
     ) -> None:
         """Queue a finish operation using a stable idempotency key."""
         operation = Operation(
@@ -136,6 +147,7 @@ class AgentInstanceManager:
             payload={
                 "instance_id": instance_id,
                 "idempotency_key": idempotency_key,
+                "status": status,
             },
             timestamp=datetime.now(timezone.utc),
         )
@@ -199,16 +211,21 @@ class AgentInstanceHandle:
             self._start_idempotency_key,
         )
 
-    async def finish(self) -> None:
+    async def finish(self, status: "FinishStatus" = "complete") -> None:
         """Mark the instance as finished.
 
         This queues a finish operation for the instance.
+
+        Args:
+            status: Terminal status for the instance — one of ``"complete"``,
+                ``"failed"``, or ``"cancelled"``. Defaults to ``"complete"``.
         """
         manager = self._client.instance_manager
         assert manager is not None
         await manager.finish_with_idempotency_key(
             self._instance_id,
             self._finish_idempotency_key,
+            status=status,
         )
 
     async def create_span(

prefactor_core-0.2.4/tests/test_agent_instance_finish_status.py

@@ -0,0 +1,104 @@
+"""Tests for AgentInstanceHandle.finish() accepting an optional status.
+
+See GitHub issue prefactordev/python-sdk#13.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+from prefactor_core import PrefactorCoreClient
+from prefactor_core.config import PrefactorCoreConfig, QueueConfig
+from prefactor_http.config import HttpClientConfig
+
+
+class _StubAgentInstances:
+    def __init__(self) -> None:
+        self.finish_calls: list[dict] = []
+
+    async def register(self, **kwargs):
+        return SimpleNamespace(id=kwargs.get("id") or "inst-1")
+
+    async def start(self, **kwargs):
+        return SimpleNamespace(id=kwargs["agent_instance_id"])
+
+    async def finish(self, **kwargs):
+        self.finish_calls.append(kwargs)
+        return SimpleNamespace(id=kwargs["agent_instance_id"])
+
+
+class _StubAgentSpans:
+    async def create(self, **kwargs):
+        return SimpleNamespace(id="span-1")
+
+    async def finish(self, **kwargs):
+        return SimpleNamespace(id=kwargs["agent_span_id"])
+
+
+class _StubHttpClient:
+    def __init__(
+        self,
+        *_args,
+        agent_instances: _StubAgentInstances | None = None,
+        **_kwargs,
+    ) -> None:
+        self.agent_instances = agent_instances or _StubAgentInstances()
+        self.agent_spans = _StubAgentSpans()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return None
+
+
+def _make_client_config() -> PrefactorCoreConfig:
+    return PrefactorCoreConfig(
+        http_config=HttpClientConfig(
+            api_url="https://api.test.com",
+            api_token="test-token",
+            max_retries=0,
+            initial_retry_delay=0.01,
+            max_retry_delay=0.02,
+        ),
+        queue_config=QueueConfig(num_workers=1, max_retries=0),
+    )
+
+
+@pytest.mark.asyncio
+async def test_finish_without_status_defaults_to_complete():
+    """Default call to finish() should forward status='complete' to HTTP."""
+    stub_http = _StubHttpClient()
+
+    with patch("prefactor_core.client.PrefactorHttpClient", return_value=stub_http):
+        async with PrefactorCoreClient(_make_client_config()) as client:
+            instance = await client.create_agent_instance(
+                agent_id="agent-1",
+                agent_version={"name": "v1"},
+                agent_schema_version={"span_schemas": {}},
+            )
+            await instance.finish()
+
+    assert len(stub_http.agent_instances.finish_calls) == 1
+    assert stub_http.agent_instances.finish_calls[0].get("status") == "complete"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("status", ["failed", "cancelled", "complete"])
+async def test_finish_forwards_explicit_status(status):
+    """Explicit status on handle.finish() should reach the HTTP layer."""
+    stub_http = _StubHttpClient()
+
+    with patch("prefactor_core.client.PrefactorHttpClient", return_value=stub_http):
+        async with PrefactorCoreClient(_make_client_config()) as client:
+            instance = await client.create_agent_instance(
+                agent_id="agent-1",
+                agent_version={"name": "v1"},
+                agent_schema_version={"span_schemas": {}},
+            )
+            await instance.finish(status=status)
+
+    assert len(stub_http.agent_instances.finish_calls) == 1
+    assert stub_http.agent_instances.finish_calls[0]["status"] == status