openbox-temporal-sdk-python 1.1.1__tar.gz → 1.1.2__tar.gz

openbox_temporal_sdk_python-1.1.2/CHANGELOG.md

@@ -0,0 +1,124 @@
+# Changelog
+
+All notable changes to OpenBox SDK for Temporal Workflows.
+
+## [1.1.2] - 2026-04-22
+
+### Security
+
+- **API key no longer flows through workflow history.** `send_governance_event` refactored into a `GovernanceActivities` class that holds credentials on `self`; activity inputs carry only `payload`, `timeout`, and `on_api_error`. Before this change, anyone with Describe permissions on the namespace could read the API key from the recorded activity input.
+
+### Added
+
+- W3C trace propagation through Temporal headers, on by default via `enable_trace_propagation=True` on `OpenBoxPlugin` and `create_openbox_worker()`. Uses `temporalio.contrib.opentelemetry.TracingInterceptor` so spans started by the caller stitch to workflow/activity spans on the worker side.
+- `ApplicationError` type constants in `errors.py` (`GOVERNANCE_HALT_ERROR_TYPE`, `GOVERNANCE_BLOCK_ERROR_TYPE`, `GOVERNANCE_API_ERROR_TYPE`, `GOVERNANCE_STOP_ERROR_TYPE`) — single source of truth for governance error routing.
+- `openbox.activities.GovernanceActivities` class + `build_governance_activities()` factory.
+
+### Fixed
+
+- **Workflow exception shadowing** — `WorkflowFailed` event send is now wrapped in `try/except`, so a `GovernanceHaltError` from `fail_closed + API down` no longer replaces the real workflow error.
+- **String-matching on exception types** — `workflow_interceptor` now inspects `ApplicationError.type` via the exception chain instead of `"GovernanceHalt" in str(e)`. Eliminates false positives when a user workflow happens to emit an error message containing a governance keyword.
+- **Race creating governance HTTP client** — `hook_governance._get_sync_client` / `_get_async_client` now use double-checked locking. Previously two concurrent activities could each create a client, with the losing instance getting garbage-collected while its connection pool leaked.
+- **Replayer plugin coverage** — `test_plugin_integration.py` now passes `plugins=[plugin]` to `Replayer`, so replay tests validate interceptor determinism, not just user workflow code.
+- Version-pin mismatch — comments in `openbox/__init__.py` said `temporalio >= 1.24.0` but pyproject/README pin `1.23.0`. Corrected to `1.23.0`.
+
+### Changed
+
+- `plugin.py` / `worker.py` now use `logging.getLogger(__name__)` for initialization status messages instead of `print()`.
+
+## [1.1.1] - 2026-04-07
+
+### Added
+
+- **OpenBoxPlugin** — drop-in `SimplePlugin` integration for Temporal Workers. Single-line setup: `plugins=[OpenBoxPlugin(openbox_url=..., openbox_api_key=...)]`. Auto-registers interceptors, OTel instrumentation, sandbox passthrough, and `send_governance_event` activity
+- Plugin integration guide for Temporal AI Partner Ecosystem (`docs/temporal-plugin-integration-guide.md`)
+- HTTP body truncation tests (`tests/test_http_body_truncation.py`)
+- Plugin unit tests (`tests/test_plugin.py`) and integration/replay tests (`tests/test_plugin_integration.py`)
+
+### Fixed
+
+- **HTTP body truncation** — enforce `max_body_size` (default 64KB) on request/response bodies in governance spans
+- **File I/O spans** — remove raw file content from governance payloads; only `bytes_read`/`bytes_written` metadata sent
+- **error_type sanitization** — prevent serialized error objects from being sent as `error.cause.error_type` string in WorkflowFailed payloads
+- Remove useless f-strings, redundant `(ImportError, Exception)` clauses, merge nested if statements
+- Prefix unused `span` param in urllib hook
+
+### Changed
+
+- `temporalio>=1.23.0` (from 1.8.0) for SimplePlugin support
+- `GovernanceConfig.max_body_size` default changed from `None` (unlimited) to `65536` (64KB)
+- `\w` regex shorthand in API key pattern
+
+### Refactored
+
+- Reduce cognitive complexity across 7 modules: `activity_interceptor.py` (126→split), `workflow_interceptor.py` (40→split), `activities.py` (20→split), `db_governance_hooks.py` (34→split), `otel_setup.py` (51→split), `tracing.py` (85→split), `verdict_handler.py` (16→15)
+- Extract shared helpers: `_run_governed_query_sync/async`, `_build_error_dict`, `_extract_dbapi_context`, `_instrument_sqlalchemy`
+
+### Dependencies
+
+- Bump Pygments 2.19.2 → 2.20.0 (ReDoS fix, CVSS 1.9)
+
+## [1.1.0] - 2026-03-09
+
+### Added
+
+- **Hook-level governance** — real-time, per-operation governance evaluation during activity execution
+  - Every HTTP request, database query, file operation, and traced function call is evaluated at `started` (before, can block) and `completed` (after, informational) stages
+  - Same `POST /api/v1/governance/evaluate` endpoint with new `hook_trigger` field in payload
+  - Automatically enabled when using `create_openbox_worker()`
+- **Database query governance** — per-query started/completed evaluations for psycopg2, pymysql, mysql-connector, asyncpg, pymongo, redis, sqlalchemy
+- **File I/O governance** — per-operation evaluations for open, read, write, readline, readlines, writelines, close (opt-in via `instrument_file_io=True`)
+- **`@traced` decorator** (`openbox.tracing`) — function-level governance with OTel spans; zero overhead when governance not configured
+- **`GovernanceBlockedError`** — new exception type for hook-level blocking with verdict, reason, and resource identifier
+- **Abort propagation** — once one hook blocks, all subsequent hooks for the same activity short-circuit immediately
+- **HALT workflow termination** from hook-level governance via `client.terminate()`
+- **REQUIRE_APPROVAL** from hook-level governance enters the same HITL approval polling flow as activity-level approvals
+- **`duration_ns`** computed for all hook span types (HTTP, file, function — DB already had it)
+
+### Changed
+
+- **`hook_trigger` simplified to boolean** — was a dict with type/stage/data, now just `true`. All data moved to span root fields
+- **Span data consolidation** — all type-specific fields at span root (`hook_type`, `http_method`, `db_system`, `file_path`, `function`, etc.)
+- **`attributes` is OTel-original only** — no custom `openbox.*`, `http.request.*`, `db.result.*` fields injected
+- Hook governance payloads send only the current span per evaluation (not accumulated history)
+- Event-level payloads (ActivityStarted/Completed, Workflow events) no longer include spans
+- Simplified `WorkflowSpanProcessor` — removed span buffering, governed span tracking, body data merging; `on_end()` now only forwards to fallback exporters
+
+### Fixed
+
+- HALT verdict from hooks now correctly terminates the workflow (previously only stopped the activity like BLOCK)
+- REQUIRE_APPROVAL from hooks now enters the approval polling flow (previously raised unhandled error)
+- Stale buffer/verdict from previous workflow run no longer carries over when workflow_id is reused
+- Subsequent hooks no longer fire after the first hook blocks an activity
+
+## [1.0.21] - 2026-03-04
+
+### Added
+
+- Human-in-the-loop approval with expiration handling
+- Approval polling via `POST /api/v1/governance/approval`
+- Guardrails: input/output validation and redaction
+- `GovernanceVerdictResponse.from_dict()` with guardrails_result parsing
+- Output redaction for activity results
+- `_deep_update_dataclass()` for in-place dataclass field updates from redacted dicts
+
+### Fixed
+
+- Temporal Payload objects no longer slip through as non-serializable in governance payloads
+- Stale buffer detection via run_id comparison
+
+## [1.0.0] - 2026-02-15
+
+### Added
+
+- Initial release
+- 6 event types: WorkflowStarted, WorkflowCompleted, WorkflowFailed, SignalReceived, ActivityStarted, ActivityCompleted
+- 5-tier verdict system: ALLOW, CONSTRAIN, REQUIRE_APPROVAL, BLOCK, HALT
+- HTTP instrumentation via OpenTelemetry (httpx, requests, urllib3, urllib)
+- Database instrumentation (psycopg2, pymysql, asyncpg, pymongo, redis, sqlalchemy)
+- File I/O instrumentation (opt-in)
+- Zero-code setup via `create_openbox_worker()` factory
+- Workflow and activity interceptors for governance
+- Span buffering and activity context tracking
+- `fail_open` / `fail_closed` error policies
+- v1.0 backward compatibility for legacy verdict strings

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbox-temporal-sdk-python
-Version: 1.1.1
+Version: 1.1.2
 Summary: OpenBox SDK - Governance and observability for Temporal workflows
 Project-URL: Homepage, https://github.com/OpenBox-AI/temporal-sdk-python
 Project-URL: Documentation, https://github.com/OpenBox-AI/temporal-sdk-python#readme
@@ -100,7 +100,15 @@ await worker.run()
 ```
 
 The plugin automatically configures governance interceptors, OTel instrumentation,
-sandbox passthrough, and the `send_governance_event` activity.
+sandbox passthrough, W3C trace propagation through Temporal headers (via
+`temporalio.contrib.opentelemetry.TracingInterceptor`), and the
+`send_governance_event` activity.
+
+**Credentials never leave the plugin.** `openbox_api_key` is captured on the
+governance activity instance itself — it does **not** flow through activity
+inputs, so it is never written to workflow history. To opt out of trace
+propagation (e.g., if you already wire `OpenTelemetryPlugin`), pass
+`enable_trace_propagation=False`.
 
 ### Composing with Other Plugins
 
@@ -148,8 +156,10 @@ The factory automatically:
 1. Validates the API key
 2. Creates span processor
 3. Sets up OpenTelemetry instrumentation
-4. Creates governance interceptors
-5. Adds `send_governance_event` activity
+4. Creates governance interceptors (incl. W3C trace propagation)
+5. Builds the `GovernanceActivities` instance with credentials captured on
+   `self` and registers its `send_governance_event` method — the API key is
+   never passed through activity inputs / workflow history
 6. Returns fully configured Worker
 
 ---
@@ -195,6 +205,11 @@ worker = create_openbox_worker(
     # File I/O instrumentation
     instrument_file_io=False,  # disabled by default
 
+    # Header-based W3C trace propagation (client → workflow → activities).
+    # Default True. Set False if you already wire OpenTelemetryPlugin or a
+    # custom propagator.
+    enable_trace_propagation=True,
+
     # Standard Worker options (all supported)
     activity_executor=my_executor,
     max_concurrent_activities=10,
@@ -471,7 +486,7 @@ from openbox import (
 )
 from openbox.otel_setup import setup_opentelemetry_for_governance
 from openbox.activity_interceptor import ActivityGovernanceInterceptor
-from openbox.activities import send_governance_event
+from openbox.activities import build_governance_activities
 from openbox.hook_governance import FAIL_OPEN, FAIL_CLOSED  # error policy constants
 
 # 1. Initialize SDK
@@ -511,14 +526,26 @@ activity_interceptor = ActivityGovernanceInterceptor(
     config=config,
 )
 
-# 6. Create worker
+# 6. Build the governance activity instance (credentials captured on `self`
+# so they never flow through workflow history).
+governance_activities = build_governance_activities(
+    api_url="http://localhost:8086",
+    api_key="obx_test_key_1",
+)
+
+# 7. Create worker
 from temporalio.worker import Worker
+from temporalio.contrib.opentelemetry import TracingInterceptor
 worker = Worker(
     client=client,
     task_queue="my-task-queue",
     workflows=[MyWorkflow],
-    activities=[my_activity, send_governance_event],
-    interceptors=[workflow_interceptor, activity_interceptor],
+    activities=[my_activity, governance_activities.send_governance_event],
+    interceptors=[
+        workflow_interceptor,
+        activity_interceptor,
+        TracingInterceptor(),  # W3C header propagation for OTel spans
+    ],
 )
 ```
 

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/README.md

@@ -52,7 +52,15 @@ await worker.run()
 ```
 
 The plugin automatically configures governance interceptors, OTel instrumentation,
-sandbox passthrough, and the `send_governance_event` activity.
+sandbox passthrough, W3C trace propagation through Temporal headers (via
+`temporalio.contrib.opentelemetry.TracingInterceptor`), and the
+`send_governance_event` activity.
+
+**Credentials never leave the plugin.** `openbox_api_key` is captured on the
+governance activity instance itself — it does **not** flow through activity
+inputs, so it is never written to workflow history. To opt out of trace
+propagation (e.g., if you already wire `OpenTelemetryPlugin`), pass
+`enable_trace_propagation=False`.
 
 ### Composing with Other Plugins
 
@@ -100,8 +108,10 @@ The factory automatically:
 1. Validates the API key
 2. Creates span processor
 3. Sets up OpenTelemetry instrumentation
-4. Creates governance interceptors
-5. Adds `send_governance_event` activity
+4. Creates governance interceptors (incl. W3C trace propagation)
+5. Builds the `GovernanceActivities` instance with credentials captured on
+   `self` and registers its `send_governance_event` method — the API key is
+   never passed through activity inputs / workflow history
 6. Returns fully configured Worker
 
 ---
@@ -147,6 +157,11 @@ worker = create_openbox_worker(
     # File I/O instrumentation
     instrument_file_io=False,  # disabled by default
 
+    # Header-based W3C trace propagation (client → workflow → activities).
+    # Default True. Set False if you already wire OpenTelemetryPlugin or a
+    # custom propagator.
+    enable_trace_propagation=True,
+
     # Standard Worker options (all supported)
     activity_executor=my_executor,
     max_concurrent_activities=10,
@@ -423,7 +438,7 @@ from openbox import (
 )
 from openbox.otel_setup import setup_opentelemetry_for_governance
 from openbox.activity_interceptor import ActivityGovernanceInterceptor
-from openbox.activities import send_governance_event
+from openbox.activities import build_governance_activities
 from openbox.hook_governance import FAIL_OPEN, FAIL_CLOSED  # error policy constants
 
 # 1. Initialize SDK
@@ -463,14 +478,26 @@ activity_interceptor = ActivityGovernanceInterceptor(
     config=config,
 )
 
-# 6. Create worker
+# 6. Build the governance activity instance (credentials captured on `self`
+# so they never flow through workflow history).
+governance_activities = build_governance_activities(
+    api_url="http://localhost:8086",
+    api_key="obx_test_key_1",
+)
+
+# 7. Create worker
 from temporalio.worker import Worker
+from temporalio.contrib.opentelemetry import TracingInterceptor
 worker = Worker(
     client=client,
     task_queue="my-task-queue",
     workflows=[MyWorkflow],
-    activities=[my_activity, send_governance_event],
-    interceptors=[workflow_interceptor, activity_interceptor],
+    activities=[my_activity, governance_activities.send_governance_event],
+    interceptors=[
+        workflow_interceptor,
+        activity_interceptor,
+        TracingInterceptor(),  # W3C header propagation for OTel spans
+    ],
 )
 ```
 

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/docs/code-standards.md

@@ -83,10 +83,13 @@ This document defines coding standards, architectural patterns, and best practic
 async def execute_workflow(self, input: ExecuteWorkflowInput) -> Any:
     info = workflow.info()
 
-    # Send event via activity (deterministic)
+    # Send event via activity (deterministic). NEVER pass credentials
+    # (api_key) in activity inputs — workflow history is readable by anyone
+    # with Describe permissions on the namespace. The activity holds the
+    # credentials on its instance (see rule 3).
     await workflow.execute_activity(
         "send_governance_event",
-        args=[{"api_url": api_url, "payload": {...}}],
+        args=[{"payload": {...}, "timeout": 30.0, "on_api_error": "fail_open"}],
         start_to_close_timeout=timedelta(seconds=30),
     )
 
@@ -122,25 +125,36 @@ async def execute_workflow(self, input: ExecuteWorkflowInput) -> Any:
 #### Solution: Lazy Imports
 
 ```python
-# ✅ CORRECT - Lazy import in activity function
-@activity.defn(name="send_governance_event")
-async def send_governance_event(input: Dict[str, Any]):
-    import httpx  # ✅ Loaded only when activity executes
-    from datetime import datetime, timezone  # ✅ Lazy import
-
-    async with httpx.AsyncClient() as client:
-        response = await client.post(...)
-    return response.json()
+# ✅ CORRECT - Class-based activity with credentials captured on self
+class GovernanceActivities:
+    def __init__(self, api_url: str, api_key: str):
+        self._api_url = api_url
+        self._api_key = api_key
+
+    @activity.defn(name="send_governance_event")
+    async def send_governance_event(self, input: Dict[str, Any]):
+        import httpx  # ✅ Loaded only when activity executes
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self._api_url}/api/v1/governance/evaluate",
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                json=input["payload"],
+            )
+        return response.json()
 ```
 
 ```python
-# ❌ WRONG - Module-level import
-import httpx  # ❌ Loaded when module imports, triggers sandbox
-
+# ❌ WRONG - Credentials in activity input (leaks to workflow history)
 @activity.defn(name="send_governance_event")
 async def send_governance_event(input: Dict[str, Any]):
+    # ❌ input["api_key"] is persisted in workflow history — readable by
+    # anyone with Describe access to the namespace.
     async with httpx.AsyncClient() as client:
-        response = await client.post(...)
+        response = await client.post(
+            input["api_url"],
+            headers={"Authorization": f"Bearer {input['api_key']}"},
+            json=input["payload"],
+        )
     return response.json()
 ```
 

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/docs/codebase-summary.md

@@ -328,30 +328,48 @@ def create_openbox_worker(
 ### 11. Governance Event Activity (`activities.py`)
 
 **Purpose:** Execute HTTP calls to OpenBox Core from workflow context
-**Activity:** `send_governance_event`
+**Activity:** `send_governance_event` (method of `GovernanceActivities` class)
 
-**Function Signature:**
+**Class Signature:**
 ```python
-@activity.defn(name="send_governance_event")
-async def send_governance_event(input: Dict[str, Any]) -> Optional[Dict[str, Any]]
+class GovernanceActivities:
+    def __init__(self, api_url: str, api_key: str): ...
+
+    @activity.defn(name="send_governance_event")
+    async def send_governance_event(
+        self, input: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]: ...
+
+
+def build_governance_activities(api_url: str, api_key: str) -> GovernanceActivities
 ```
 
-**Input Fields:**
-- `api_url` - OpenBox Core URL
-- `api_key` - Bearer token
+The plugin / `create_openbox_worker()` factory build one instance and register
+its bound `send_governance_event` method with the Temporal Worker.
+Credentials live on `self` — they do **not** flow through activity inputs,
+so the API key is never written to workflow history.
+
+**Input Fields (activity input dict):**
 - `payload` - Event data (without timestamp)
 - `timeout` - Request timeout
 - `on_api_error` - "fail_open" or "fail_closed"
 
+> `api_url` / `api_key` are deliberately absent from the input dict to avoid
+> leaking credentials into workflow history. They are held on the activity
+> instance itself.
+
 **Behavior:**
 - Adds RFC3339 timestamp to payload
-- POSTs to `/api/v1/governance/evaluate`
+- POSTs to `{self._api_url}/api/v1/governance/evaluate`
 - Parses verdict from response
 - For SignalReceived: Returns verdict dict (workflow interceptor stores it)
 - For other events with BLOCK/HALT: Raises non-retryable `ApplicationError`
+  with `type="GovernanceBlock"` / `"GovernanceHalt"`
 - On API failure with fail_closed: Raises `GovernanceAPIError`
 
-**Lines of Code:** 163
+A module-level `send_governance_event(input)` helper remains for direct
+callers (tests, scripts) that already hold credentials; it instantiates
+`GovernanceActivities` internally and delegates.
 
 ---
 

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/openbox/__init__.py

@@ -68,7 +68,7 @@ from .span_processor import WorkflowSpanProcessor
 from .workflow_interceptor import GovernanceInterceptor
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Plugin (requires temporalio >= 1.24.0)
+# Plugin (requires temporalio >= 1.23.0)
 # ═══════════════════════════════════════════════════════════════════════════════
 
 try:
@@ -76,7 +76,7 @@ try:
 
     from .plugin import OpenBoxPlugin
 except ImportError:
-    pass  # temporalio < 1.24.0, plugin not available
+    pass  # temporalio < 1.23.0, plugin not available
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # Verdict Handler
@@ -139,7 +139,7 @@ from .client import GovernanceClient
 __all__ = [
     # Simple Worker Factory (recommended)
     "create_openbox_worker",
-    # Plugin (recommended for temporalio >= 1.24.0)
+    # Plugin (recommended for temporalio >= 1.23.0)
     "OpenBoxPlugin",
     # Configuration
     "initialize",

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/openbox/activities.py

@@ -142,60 +142,109 @@ def _handle_api_error(event_type: str, error_msg: str, on_api_error: str) -> dic
     return {"success": False, "error": error_msg}
 
 
-@activity.defn(name="send_governance_event")
-async def send_governance_event(input: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """
-    Activity that sends governance events to OpenBox Core.
+class GovernanceActivities:
+    """Container for Temporal activities that need OpenBox credentials.
 
-    Called from WorkflowInboundInterceptor via workflow.execute_activity()
-    to maintain workflow determinism.
+    Credentials live on the instance (never in activity inputs → never in
+    workflow history → not visible to anyone with namespace read access).
+    The worker registers bound methods of a single instance, created at
+    worker-init time by the plugin / create_openbox_worker factory.
     """
-    api_url = input.get("api_url", "")
-    api_key = input.get("api_key", "")
-    event_payload = input.get("payload", {})
-    timeout = input.get("timeout", 30.0)
-    on_api_error = input.get("on_api_error", "fail_open")
-
-    # Add timestamp in activity context (non-deterministic code allowed)
-    payload = {**event_payload, "timestamp": _rfc3339_now()}
-    event_type = event_payload.get("event_type", "unknown")
-
-    try:
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.post(
-                f"{api_url}/api/v1/governance/evaluate",
-                json=payload,
-                headers=build_auth_headers(api_key),
-            )
-
-            if response.status_code != 200:
-                return _handle_api_error(
-                    event_type,
-                    f"HTTP {response.status_code}: {response.text}",
-                    on_api_error,
+
+    def __init__(self, api_url: str, api_key: str):
+        self._api_url = api_url.rstrip("/")
+        self._api_key = api_key
+
+    @activity.defn(name="send_governance_event")
+    async def send_governance_event(
+        self, input: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """Send a governance event to OpenBox Core.
+
+        Called from WorkflowInboundInterceptor via workflow.execute_activity()
+        to maintain workflow determinism. The `input` dict carries only the
+        event payload and per-call policy — never credentials.
+        """
+        event_payload = input.get("payload", {})
+        timeout = input.get("timeout", 30.0)
+        on_api_error = input.get("on_api_error", "fail_open")
+
+        # Add timestamp in activity context (non-deterministic code allowed)
+        payload = {**event_payload, "timestamp": _rfc3339_now()}
+        event_type = event_payload.get("event_type", "unknown")
+
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.post(
+                    f"{self._api_url}/api/v1/governance/evaluate",
+                    json=payload,
+                    headers=build_auth_headers(self._api_key),
                 )
 
-            data = response.json()
-            verdict = Verdict.from_string(
-                data.get("verdict") or data.get("action", "continue")
-            )
-            reason = data.get("reason")
-            policy_id = data.get("policy_id")
-            risk_score = data.get("risk_score", 0.0)
-
-            if verdict.should_stop():
-                result = await _handle_stop_verdict(
-                    verdict, reason, policy_id, risk_score, event_type, event_payload
+                if response.status_code != 200:
+                    return _handle_api_error(
+                        event_type,
+                        f"HTTP {response.status_code}: {response.text}",
+                        on_api_error,
+                    )
+
+                data = response.json()
+                verdict = Verdict.from_string(
+                    data.get("verdict") or data.get("action", "continue")
                 )
-                if result:
-                    return result
-
-            return _build_verdict_result(verdict, reason, policy_id, risk_score)
-
-    except (GovernanceAPIError, ApplicationError):
-        raise
-    except Exception as e:
-        logger.warning(f"Failed to send {event_type} event: {e}")
-        if on_api_error == "fail_closed":
-            raise GovernanceAPIError(str(e))
-        return {"success": False, "error": str(e)}
+                reason = data.get("reason")
+                policy_id = data.get("policy_id")
+                risk_score = data.get("risk_score", 0.0)
+
+                if verdict.should_stop():
+                    result = await _handle_stop_verdict(
+                        verdict,
+                        reason,
+                        policy_id,
+                        risk_score,
+                        event_type,
+                        event_payload,
+                    )
+                    if result:
+                        return result
+
+                return _build_verdict_result(verdict, reason, policy_id, risk_score)
+
+        except (GovernanceAPIError, ApplicationError):
+            raise
+        except Exception as e:
+            logger.warning(f"Failed to send {event_type} event: {e}")
+            if on_api_error == "fail_closed":
+                raise GovernanceAPIError(str(e))
+            return {"success": False, "error": str(e)}
+
+
+def build_governance_activities(
+    api_url: str, api_key: str
+) -> GovernanceActivities:
+    """Factory used by plugin.py and worker.py to build the activities instance."""
+    return GovernanceActivities(api_url=api_url, api_key=api_key)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Backward-compat module-level helper.
+#
+# Not decorated with @activity.defn — worker/plugin register the class-based
+# version above so credentials never flow through activity inputs. This shim
+# exists for direct callers (tests, scripts) who already hold credentials and
+# want to invoke the HTTP logic without constructing the class themselves.
+# ─────────────────────────────────────────────────────────────────────────────
+async def send_governance_event(input: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Backward-compat wrapper — delegates to GovernanceActivities.
+
+    Tests and direct callers can keep passing api_url/api_key in the input
+    dict. The class-based activity registered with the worker does NOT see
+    these fields (it reads credentials from self), so nothing written to
+    workflow history ever carries the API key.
+    """
+    instance = GovernanceActivities(
+        api_url=input.get("api_url", ""),
+        api_key=input.get("api_key", ""),
+    )
+    forwarded = {k: v for k, v in input.items() if k not in ("api_url", "api_key")}
+    return await instance.send_governance_event(forwarded)

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/openbox/db_governance_hooks.py

@@ -68,9 +68,14 @@ def _classify_sql(query: Any) -> str:
 
 
 def _generate_span_id() -> str:
-    """Generate a random 16-hex-char span ID for pymongo governance spans."""
-    import random
-    return format(random.getrandbits(64), "016x")
+    """Generate a random 16-hex-char span ID for pymongo governance spans.
+
+    Uses secrets (CSPRNG) rather than random — span IDs are not secrets, but
+    the stronger generator silences security scanners without runtime cost
+    and removes any chance of cross-trace ID collision under heavy load.
+    """
+    import secrets
+    return secrets.token_hex(8)
 
 
 def _build_db_span_data(

{openbox_temporal_sdk_python-1.1.1 → openbox_temporal_sdk_python-1.1.2}/openbox/errors.py

@@ -21,12 +21,26 @@ Hierarchy:
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Final, Union
 
 if TYPE_CHECKING:
     from .types import Verdict
 
 
+# ═══════════════════════════════════════════════════════════════════
+# ApplicationError.type values raised by governance activities.
+# Use these constants — never string-match on error messages or
+# exception class names (brittle against locale / reformatting /
+# Temporal's ActivityError wrapping).
+# ═══════════════════════════════════════════════════════════════════
+
+GOVERNANCE_HALT_ERROR_TYPE: Final[str] = "GovernanceHalt"
+GOVERNANCE_BLOCK_ERROR_TYPE: Final[str] = "GovernanceBlock"
+GOVERNANCE_API_ERROR_TYPE: Final[str] = "GovernanceAPIError"
+# Legacy alias; kept for histories predating the rename.
+GOVERNANCE_STOP_ERROR_TYPE: Final[str] = "GovernanceStop"
+
+
 # ═══════════════════════════════════════════════════════════════════
 # Base
 # ═══════════════════════════════════════════════════════════════════