bazaar-compute-node 0.1.18__tar.gz → 0.1.20__tar.gz

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.18
+Version: 0.1.20
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.18"
+version = "0.1.20"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.18"
+version = "0.1.20"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/app/command.py

@@ -27,6 +27,7 @@ def serialize_inbound(message: InboundMessage) -> dict[str, object]:
             if message.sender is None
             else {"id": message.sender.id, "name": message.sender.name}
         ),
+        "sender_kind": message.sender_kind.value,
         "message_type": message.message_type,
         "canonical_target": message.canonical_target,
         "target_kind": message.target_kind.value,

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/app/wrapper.py

@@ -32,16 +32,30 @@ def install_bcc_wrapper(bin_dir: Path, *, agent_id: str) -> Path:
             command_path.write_text(
                 "@echo off\n"
                 f'set "BCN_AGENT_ID={agent_id}"\n'
-                'set "PYTHONUTF8=1"\n'
                 'set "PYTHONIOENCODING=utf-8"\n'
+                'set "PYTHONUTF8=1"\n'
+                'set "LANG=C.UTF-8"\n'
+                'set "LC_ALL=C.UTF-8"\n'
+                "chcp 65001 >NUL 2>NUL\n"
                 f'"{python_executable}" -m bazaar_compute_node.bcc %*\n',
                 encoding="utf-8",
             )
             (bin_dir / "bcc.ps1").write_text(
+                "$ErrorActionPreference = 'Stop'\n"
                 f"$env:BCN_AGENT_ID = '{agent_id}'\n"
-                "$env:PYTHONUTF8 = '1'\n"
+                "$utf8NoBom = [System.Text.UTF8Encoding]::new($false)\n"
+                "[Console]::OutputEncoding = $utf8NoBom\n"
+                "$OutputEncoding = $utf8NoBom\n"
                 "$env:PYTHONIOENCODING = 'utf-8'\n"
-                f'& "{python_executable}" -m bazaar_compute_node.bcc @args\n'
+                "$env:PYTHONUTF8 = '1'\n"
+                "$env:LANG = 'C.UTF-8'\n"
+                "$env:LC_ALL = 'C.UTF-8'\n"
+                f'$python = "{python_executable}"\n'
+                "if ($MyInvocation.ExpectingInput) {\n"
+                "    $input | & $python -m bazaar_compute_node.bcc @args\n"
+                "} else {\n"
+                "    & $python -m bazaar_compute_node.bcc @args\n"
+                "}\n"
                 "exit $LASTEXITCODE\n",
                 encoding="utf-8",
             )

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/bcc.py

@@ -480,6 +480,9 @@ def _message_header_fields(
 ) -> tuple[str, str, str, str, str | None, str]:
     target = _require_text(message, "canonical_target")
     message_id = _require_text(message, "message_id")
+    sender_kind = _require_text(message, "sender_kind")
+    if sender_kind not in {"human", "agent", "unknown"}:
+        _invalid_response("command response contains an invalid sender_kind")
     sender_value = message.get("sender")
     sender: str | None = None
     if sender_value is not None:
@@ -493,7 +496,7 @@ def _message_header_fields(
         target,
         message_id,
         _format_message_timestamp(message),
-        _require_text(message, "message_type"),
+        sender_kind,
         sender,
         _require_text(message, "body", allow_empty=True),
     )

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/contrib/lark/channel.py

@@ -27,6 +27,7 @@ from ...core.models import (
     RuntimeEvent,
     RuntimeEventState,
     SenderIdentity,
+    SenderKind,
     StreamEvent,
 )
 from ...core.outcomes import ProviderCallResult, ProviderCallStatus
@@ -481,6 +482,18 @@ class LarkChannel(IChannel):
             tenant_key=tenant_key,
         )
         metadata = dict(provider_payload_metadata or {})
+        sender_type = (
+            _provider_text(sender_payload.get("sender_type"))
+            if isinstance(sender_payload, Mapping)
+            else None
+        )
+        if sender_type == "user":
+            sender_kind = SenderKind.HUMAN
+        elif sender_type in {"app", "bot", "system"}:
+            sender_kind = SenderKind.AGENT
+        else:
+            sender_kind = SenderKind.UNKNOWN
+        metadata.setdefault("sender_kind", sender_kind.value)
         if projection.content_error:
             metadata["content_parse_failed"] = True
         return InboundMessage(
@@ -758,7 +771,14 @@ class LarkChannel(IChannel):
             )
         api = self._api
         identity = self._identity
-        if api is None or identity is None or self._state not in {"connected", "ready"}:
+        transport = self._transport
+        if (
+            api is None
+            or identity is None
+            or transport is None
+            or self._state not in {"connected", "ready"}
+            or transport.state != "connected"
+        ):
             return ProviderCallResult(
                 status=ProviderCallStatus.FAILED,
                 error_kind="channel_unavailable",
@@ -779,6 +799,18 @@ class LarkChannel(IChannel):
                 error_message="Lark delivery timed out waiting for the send lock",
             )
         try:
+            if (
+                self._api is not api
+                or self._identity is not identity
+                or self._transport is not transport
+                or self._state not in {"connected", "ready"}
+                or transport.state != "connected"
+            ):
+                return ProviderCallResult(
+                    status=ProviderCallStatus.FAILED,
+                    error_kind="channel_unavailable",
+                    error_message="Lark channel is not available",
+                )
             return await send_outbound(
                 api,
                 identity=identity,

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/contrib/lark/transport.py

@@ -421,6 +421,7 @@ class LarkTransport:
         started_at = monotonic()
         self._events_received += 1
         self._last_event_at_ms = time_ns() // 1_000_000
+        ack_sent = False
         try:
             handler = self._on_message
             if handler is None:
@@ -429,6 +430,11 @@ class LarkTransport:
                 self._last_message_filter_reason = "handler_unavailable"
                 await self._send_ack(frame, code=200, started_at=started_at)
                 return
+
+            direct_response = _is_direct_response(message_type, decoded)
+            if not direct_response:
+                await self._send_ack(frame, code=200, started_at=started_at)
+                ack_sent = True
             result = handler(message_type, decoded, frame)
             if asyncio.iscoroutine(result) or isinstance(result, Awaitable):
                 result = await result
@@ -436,8 +442,9 @@ class LarkTransport:
             ack_payload: bytes | None = None
             if isinstance(result, LarkAck):
                 accepted = result.accepted
-                ack_code = result.code
-                ack_payload = result.payload
+                if direct_response:
+                    ack_code = result.code
+                    ack_payload = result.payload
             else:
                 accepted = result is not False
             if not accepted:
@@ -448,12 +455,14 @@ class LarkTransport:
                 self._messages_queued += 1
                 self._last_message_disposition = "queued"
                 self._last_message_filter_reason = None
-            await self._send_ack(
-                frame,
-                code=ack_code,
-                payload=ack_payload,
-                started_at=started_at,
-            )
+            if direct_response:
+                await self._send_ack(
+                    frame,
+                    code=ack_code,
+                    payload=ack_payload,
+                    started_at=started_at,
+                )
+                ack_sent = True
             if isinstance(result, LarkAck) and result.post_ack is not None:
                 post_ack_task = asyncio.create_task(
                     _run_post_ack(result.post_ack),
@@ -464,7 +473,8 @@ class LarkTransport:
         except Exception:  # noqa: BLE001
             self._message_mapping_failures += 1
             self._last_message_disposition = "failed"
-            await self._send_ack(frame, code=500, started_at=started_at)
+            if not ack_sent:
+                await self._send_ack(frame, code=500, started_at=started_at)
 
     async def _send_ack(
         self,
@@ -574,6 +584,21 @@ class LarkTransport:
         await timer.wait()
 
 
+def _is_direct_response(
+    message_type: str,
+    payload: Mapping[str, object],
+) -> bool:
+    if message_type == MESSAGE_CARD:
+        return True
+    header = payload.get("header")
+    if not isinstance(header, Mapping):
+        return False
+    return header.get("event_type") in {
+        "card.action.trigger",
+        "p2.card.action.trigger",
+    }
+
+
 def _delay_ms(seconds: float) -> int:
     return math.ceil(max(0.0, seconds) * 1_000)
 

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/contrib/telegram/channel.py

@@ -24,6 +24,7 @@ from ...core.models import (
     RuntimeEvent,
     RuntimeEventState,
     SenderIdentity,
+    SenderKind,
 )
 from ...core.outcomes import ProviderCallResult, ProviderCallStatus
 from ...core.runtime import RuntimeStreamItem
@@ -613,6 +614,7 @@ class TelegramChannel(IChannel):
                     "telegram_chat_id": chat_id,
                     "telegram_message_thread_id": topic_id,
                     "telegram_chat_type": chat_type,
+                    "sender_kind": self._sender_kind(message).value,
                     "historical": historical,
                     "activation_reason": activation_reason,
                     "rich_message": content.rich_message,
@@ -702,6 +704,7 @@ class TelegramChannel(IChannel):
                     "telegram_chat_id": identity.chat_id,
                     "telegram_message_thread_id": identity.topic_id,
                     "telegram_chat_type": chat_type,
+                    "sender_kind": self._sender_kind(reply).value,
                     "historical": historical,
                     "activation_reason": "none",
                     "quoted_backfill": True,
@@ -797,6 +800,17 @@ class TelegramChannel(IChannel):
                 )
         return None
 
+    @staticmethod
+    def _sender_kind(message: Mapping[str, object]) -> SenderKind:
+        provider_sender = message.get("from")
+        if isinstance(provider_sender, Mapping):
+            is_bot = provider_sender.get("is_bot")
+            if is_bot is True:
+                return SenderKind.AGENT
+            if is_bot is False:
+                return SenderKind.HUMAN
+        return SenderKind.UNKNOWN
+
     @staticmethod
     def _text_projection(
         message: Mapping[str, object],

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/core/models/__init__.py

@@ -28,6 +28,7 @@ from .states import (
     ReminderState,
     RuntimeEventState,
     RuntimeTurnState,
+    SenderKind,
     SessionRuntimeObservation,
     SessionRuntimeObservationSource,
     SessionRuntimeSignal,
@@ -67,6 +68,7 @@ __all__ = [
     "RuntimeTurn",
     "RuntimeTurnState",
     "SenderIdentity",
+    "SenderKind",
     "SessionRuntimeObservation",
     "SessionRuntimeObservationSource",
     "SessionRuntimeSignal",

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/core/models/entities.py

@@ -16,6 +16,7 @@ from .states import (
     OutboundDeliveryState,
     RuntimeEventState,
     RuntimeTurnState,
+    SenderKind,
     StreamEventKind,
     ensure_transition,
 )
@@ -306,6 +307,18 @@ class InboundMessage:
         if self.provider_time_ms is not None:
             _validate_non_negative(self.provider_time_ms, "provider_time_ms")
 
+    @property
+    def sender_kind(self) -> SenderKind:
+        value = self.metadata.get("sender_kind", SenderKind.UNKNOWN.value)
+        if not isinstance(value, str):
+            raise TypeError("metadata sender_kind must be a string")
+        try:
+            return SenderKind(value)
+        except ValueError as error:
+            raise ValueError(
+                "metadata sender_kind must be human, agent, or unknown"
+            ) from error
+
 
 @dataclass(frozen=True, slots=True)
 class OutboundMessage:

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/core/models/states.py

@@ -276,6 +276,12 @@ class ApprovalDecision(StrEnum):
     REJECTED = "rejected"
 
 
+class SenderKind(StrEnum):
+    HUMAN = "human"
+    AGENT = "agent"
+    UNKNOWN = "unknown"
+
+
 class ReminderState(StrEnum):
     SCHEDULED = "scheduled"
     FIRED = "fired"

{bazaar_compute_node-0.1.18 → bazaar_compute_node-0.1.20}/src/bazaar_compute_node/core/orchestration/turn.py

@@ -12,6 +12,7 @@ from ..concurrency import ISessionConcurrency
 from ..correlation import CorrelationContext
 from ..lifecycle import TimeoutBudget
 from ..models import (
+    ApprovalDecision,
     ApprovalRequest,
     ApprovalResult,
     BcnSession,
@@ -22,6 +23,7 @@ from ..models import (
     RuntimeSession,
     RuntimeTurn,
     RuntimeTurnState,
+    SenderKind,
     SessionRuntimeObservation,
     SessionRuntimeObservationSource,
     SessionRuntimeSignal,
@@ -179,38 +181,58 @@ class SessionTurnCoordinator:
                 request_id=request_id,
                 inbound_seq=message.seq,
             )
+            sender_kind = message.sender_kind
             await self._audit.append(
                 event_name="approval.requested",
                 state=RuntimeEventState.STARTED,
                 correlation=approval_correlation,
-                metadata={"action": request.action},
+                metadata={
+                    "action": request.action,
+                    "sender_kind": sender_kind.value,
+                },
             )
-            try:
-                channel_request = ChannelApprovalRequest(
-                    approval=request,
-                    target_kind=context.channel_session.target_kind,
-                    provider_thread_id=context.channel_session.provider_thread_id,
-                    provider_reply_to_message_id=message.provider_message_id,
-                    provider_sender_id=(
-                        message.sender.id if message.sender is not None else None
-                    ),
+            if sender_kind is not SenderKind.HUMAN:
+                rejection_reason = (
+                    "agent_cannot_approve"
+                    if sender_kind is SenderKind.AGENT
+                    else "unknown_sender_cannot_approve"
                 )
-                result = await self._channel.request_approval(
-                    channel_request,
-                    timeout=timeout,
+                result = ApprovalResult(
+                    request_id=request_id,
+                    decision=ApprovalDecision.REJECTED,
+                    decided_at_ms=self._clock(),
+                    reason=rejection_reason,
                 )
-                if result.request_id != request_id:
-                    raise ValueError("channel approval result correlation mismatch")
-            except Exception as error:
-                await self._audit.append(
-                    event_name="approval.failed",
-                    state=RuntimeEventState.FAILED,
-                    correlation=approval_correlation,
-                    error_kind=ErrorKind.PROVIDER_FAILED,
-                    error_message=f"approval failed: {type(error).__name__}",
-                    metadata={"action": request.action},
-                )
-                raise
+            else:
+                try:
+                    channel_request = ChannelApprovalRequest(
+                        approval=request,
+                        target_kind=context.channel_session.target_kind,
+                        provider_thread_id=context.channel_session.provider_thread_id,
+                        provider_reply_to_message_id=message.provider_message_id,
+                        provider_sender_id=(
+                            message.sender.id if message.sender is not None else None
+                        ),
+                    )
+                    result = await self._channel.request_approval(
+                        channel_request,
+                        timeout=timeout,
+                    )
+                    if result.request_id != request_id:
+                        raise ValueError("channel approval result correlation mismatch")
+                except Exception as error:
+                    await self._audit.append(
+                        event_name="approval.failed",
+                        state=RuntimeEventState.FAILED,
+                        correlation=approval_correlation,
+                        error_kind=ErrorKind.PROVIDER_FAILED,
+                        error_message=f"approval failed: {type(error).__name__}",
+                        metadata={
+                            "action": request.action,
+                            "sender_kind": sender_kind.value,
+                        },
+                    )
+                    raise
             await self._audit.append(
                 event_name="approval.decided",
                 state=RuntimeEventState.COMPLETED,
@@ -218,6 +240,8 @@ class SessionTurnCoordinator:
                 metadata={
                     "action": request.action,
                     "decision": result.decision.value,
+                    "sender_kind": sender_kind.value,
+                    **({"reason": result.reason} if result.reason is not None else {}),
                 },
             )
             return result