bazaar-compute-node 0.2.0rc1__tar.gz → 0.2.0rc2__tar.gz

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.2.0rc1
+Version: 0.2.0rc2
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -51,11 +51,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/README.md

@@ -32,11 +32,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/pyproject.toml

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

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/pyproject.toml.orig

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

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/app/agent.py

@@ -13,6 +13,7 @@ from functools import partial
 from pathlib import Path
 
 from ..core.actor import Actor, Actors, Agent, Thread
+from ..core.audit import AuditRecorder
 from ..core.channel import Channel, ChannelContext, IChannel
 from ..core.concurrency import IThreadConcurrency, ThreadLockRegistry
 from ..core.lifecycle import TimeoutBudget
@@ -28,6 +29,7 @@ from ..core.paths import resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext
 from ..core.storage import IStorageScope
 from ..core.timerwheel import TimerWheel
+from ..core.utils.clock import now_ms
 from ..i18n import Translator
 from .attachments import AttachmentMaterializer
 from .command import CommandDispatchError
@@ -104,6 +106,11 @@ class AgentApplication:
             self.workspace_path,
             self._referenced_attachment_paths,
         )
+        self._audit_recorder = AuditRecorder(
+            sink=audit,
+            timeout_budget=timeout_budget,
+            clock=now_ms,
+        )
         provider_channel = factories.channel.build(
             ChannelContext(
                 agent_id=self.agent_id,
@@ -112,6 +119,7 @@ class AgentApplication:
                 workspace=self.workspace_path,
                 translator=self.translator,
                 timer_wheel=self.timer_wheel,
+                audit=self._audit_recorder,
             )
         )
         self.channel: IChannel = Channel(self.agent_id, provider_channel)
@@ -163,7 +171,7 @@ class AgentApplication:
             channel=self.channel,
             runtimes=self.runtimes,
             storage=self.storage,
-            audit=self.audit,
+            audit=self._audit_recorder,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
             runtime_idle_timeout_ms=(

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/contrib/telegram/approval.py

@@ -36,8 +36,14 @@ class _PendingApproval:
 
 
 class TelegramApprovalChannel(TelegramChannel):
-    def __init__(self, context: ChannelContext, *, token: str) -> None:
-        super().__init__(context, token=token)
+    def __init__(
+        self,
+        context: ChannelContext,
+        *,
+        token: str,
+        allowed_sender_ids: frozenset[int],
+    ) -> None:
+        super().__init__(context, token=token, allowed_sender_ids=allowed_sender_ids)
         self._translator: Translator = context.translator or create_translator(ENGLISH)
         self._pending_approvals: dict[str, _PendingApproval] = {}
         self._approval_tokens_by_request: dict[str, str] = {}

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/contrib/telegram/channel.py

@@ -17,6 +17,7 @@ from ...core.channel import (
     ChannelSendRequest,
     IChannel,
 )
+from ...core.correlation import CorrelationContext
 from ...core.models import (
     ApprovalDecision,
     ApprovalResult,
@@ -28,6 +29,7 @@ from ...core.models import (
     InboundAttachment,
     Message,
     MessageDirection,
+    RuntimeEventState,
     RuntimeOutputEvent,
     SenderIdentity,
     SenderKind,
@@ -44,6 +46,7 @@ from ...core.models import (
     TurnUnknown,
     UsageUpdated,
 )
+from ...core.observability import LogLevel
 from ...core.outcomes import ProviderCallResult, ProviderCallStatus
 from ...core.timerwheel import TimerWheel
 from .api import TelegramApiError, TelegramBotApi, TelegramTransportError
@@ -95,9 +98,16 @@ class _InboundUpdate:
 
 
 class TelegramChannel(IChannel):
-    def __init__(self, context: ChannelContext, *, token: str) -> None:
+    def __init__(
+        self,
+        context: ChannelContext,
+        *,
+        token: str,
+        allowed_sender_ids: frozenset[int],
+    ) -> None:
         self._context = context
         self._token = token
+        self._allowed_sender_ids = allowed_sender_ids
         self._timer_wheel: TimerWheel | None = context.timer_wheel
         self._started_at_s = time_ns() // 1_000_000_000
         self._inbound: asyncio.Queue[Message | object] = asyncio.Queue()
@@ -653,6 +663,31 @@ class TelegramChannel(IChannel):
         chat_type = chat.get("type")
         if chat_type not in {"private", "group", "supergroup"}:
             return "unsupported_chat_type"
+        # Anyone on Telegram can open a private chat with a bot. A group has to
+        # be joined, so only the private case is closed here.
+        if chat_type == "private" and not (
+            isinstance(provider_sender, Mapping)
+            and provider_sender.get("id") in self._allowed_sender_ids
+        ):
+            audit = self._context.audit
+            if audit is not None:
+                await audit.append(
+                    event_name="channel.inbound.rejected",
+                    state=RuntimeEventState.COMPLETED,
+                    correlation=CorrelationContext(
+                        node_id=self._context.agent_id,
+                        channel=self.name,
+                    ),
+                    level=LogLevel.WARNING,
+                    metadata={
+                        "reason": "unauthorized_sender",
+                        "telegram_sender_id": provider_sender.get("id")
+                        if isinstance(provider_sender, Mapping)
+                        else None,
+                        "telegram_chat_id": chat.get("id"),
+                    },
+                )
+            return "unauthorized_sender"
         chat_id = chat.get("id")
         provider_message_id = message.get("message_id")
         provider_time_s = message.get("date")

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/contrib/telegram/outbound.py

@@ -64,8 +64,9 @@ class TelegramOutboundChannel(TelegramApprovalChannel):
         context: ChannelContext,
         *,
         token: str,
+        allowed_sender_ids: frozenset[int],
     ) -> None:
-        super().__init__(context, token=token)
+        super().__init__(context, token=token, allowed_sender_ids=allowed_sender_ids)
         self._outbound_requests = 0
         self._outbound_confirmed_requests = 0
         self._outbound_partial_requests = 0

bazaar_compute_node-0.2.0rc2/src/bazaar_compute_node/contrib/telegram/plugin.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+from typing import cast
+
+from ...core.channel import ChannelContext, IChannel, IChannelBuilder
+from .outbound import TelegramOutboundChannel
+
+
+class TelegramBuilder(IChannelBuilder):
+    def build(self, context: ChannelContext) -> IChannel:
+        token_env = context.options.get("token_env")
+        if not isinstance(token_env, str) or not token_env:
+            raise ValueError("agent.channel.token_env is required for telegram")
+        token = os.environ.get(token_env)
+        if token is None or not token.strip():
+            raise ValueError(f"telegram credential environment is missing: {token_env}")
+        raw_allowed = context.options.get("allowed_sender_ids")
+        if not isinstance(raw_allowed, list) or not raw_allowed:
+            raise ValueError(
+                "agent.channel.allowed_sender_ids is required for telegram "
+                "and must be a non-empty list"
+            )
+        # A username can be changed at will, so it cannot carry authority;
+        # only the numeric id can.
+        if any(
+            not isinstance(sender_id, int) or isinstance(sender_id, bool)
+            for sender_id in cast(list[object], raw_allowed)
+        ):
+            raise ValueError(
+                "agent.channel.allowed_sender_ids must hold Telegram user ids"
+            )
+        return TelegramOutboundChannel(
+            context,
+            token=token,
+            allowed_sender_ids=frozenset(cast(list[int], raw_allowed)),
+        )
+
+
+builder = TelegramBuilder()
+
+
+__all__ = ["TelegramBuilder", "builder"]

bazaar_compute_node-0.2.0rc2/src/bazaar_compute_node/core/audit.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import cast
+
+from .correlation import CorrelationContext
+from .lifecycle import TimeoutBudget
+from .models import RuntimeEventState
+from .observability import IAudit, LogLevel
+from .utils.sanitization import is_sensitive_field, omit_sensitive_fields
+
+
+class ErrorKind(StrEnum):
+    CANCELLED = "cancelled"
+    TIMEOUT = "timeout"
+    VALIDATION = "validation"
+    SESSION_NOT_FOUND = "session_not_found"
+    TARGET_NOT_REPLYABLE = "target_not_replyable"
+    EMPTY_BODY = "empty_body"
+    FRESH_CHECK_REQUIRED = "fresh_check_required"
+    FRESH_CHECK_FAILED = "fresh_check_failed"
+    PROVIDER_FAILED = "provider_failed"
+    PROVIDER_PARTIAL = "provider_partial"
+    PROVIDER_UNKNOWN = "provider_unknown"
+    PROTOCOL = "protocol"
+    STORAGE = "storage"
+    SHUTDOWN_TIMEOUT = "shutdown_timeout"
+    INTERNAL = "internal"
+
+
+@dataclass(frozen=True, slots=True)
+class AuditEvent:
+    """Sanitized append-only event contract shared by all adapters."""
+
+    event_name: str
+    state: RuntimeEventState
+    created_at_ms: int
+    correlation: CorrelationContext
+    level: LogLevel = LogLevel.INFO
+    duration_ms: int | None = None
+    error_kind: ErrorKind | None = None
+    error_type: str | None = None
+    error_message: str | None = None
+    traceback_ref: str | None = None
+    metadata: Mapping[str, object] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.error_kind is None and any(
+            value is not None
+            for value in (
+                self.error_type,
+                self.error_message,
+                self.traceback_ref,
+            )
+        ):
+            raise ValueError("error details require an error_kind")
+        pending: list[object] = [self.metadata]
+        while pending:
+            value = pending.pop()
+            if isinstance(value, Mapping):
+                for key, item in value.items():
+                    if not isinstance(key, str):
+                        raise TypeError("audit metadata keys must be strings")
+                    if is_sensitive_field(key):
+                        raise ValueError(
+                            f"audit metadata cannot contain sensitive field: {key}"
+                        )
+                    pending.append(item)
+            elif isinstance(value, list | tuple):
+                pending.extend(value)
+
+
+class AuditRecorder:
+    """Write sanitized session audit events with one shared policy."""
+
+    def __init__(
+        self,
+        *,
+        sink: IAudit,
+        timeout_budget: TimeoutBudget,
+        clock: Callable[[], int],
+    ) -> None:
+        self._sink = sink
+        self._timeout_budget = timeout_budget
+        self._clock = clock
+        self._logger = logging.getLogger("bazaar_compute_node.audit.fallback")
+
+    async def append(
+        self,
+        *,
+        event_name: str,
+        state: RuntimeEventState,
+        correlation: CorrelationContext,
+        level: LogLevel | None = None,
+        error_kind: ErrorKind | None = None,
+        error_message: str | None = None,
+        metadata: Mapping[str, object] | None = None,
+    ) -> None:
+        # how severe an event is belongs to whoever raises it; the fallback is
+        # for the callers that have no opinion
+        if level is None:
+            level = LogLevel.ERROR if error_kind else LogLevel.INFO
+        event = AuditEvent(
+            event_name=event_name,
+            state=state,
+            created_at_ms=self._clock(),
+            correlation=correlation,
+            level=level,
+            error_kind=error_kind,
+            error_message=error_message,
+            metadata=cast(Mapping[str, object], omit_sensitive_fields(metadata or {})),
+        )
+        try:
+            await self._sink.append(
+                event,
+                timeout=self._timeout_budget.command_seconds,
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            self._logger.exception(
+                "audit append failed",
+                extra={"event_name": event_name},
+            )
+
+    async def append_tool(
+        self,
+        *,
+        operation: str,
+        status: str,
+        state: RuntimeEventState,
+        correlation: CorrelationContext,
+        arguments: Mapping[str, object],
+        error_kind: ErrorKind | None = None,
+        error_message: str | None = None,
+    ) -> None:
+        safe_arguments = cast(Mapping[str, object], omit_sensitive_fields(arguments))
+        await self.append(
+            event_name=f"tool.{operation}.{status}",
+            state=state,
+            correlation=correlation,
+            error_kind=error_kind,
+            error_message=error_message,
+            metadata={
+                "kind": "tool_call",
+                "operation": operation,
+                "status": status,
+                "arguments": safe_arguments,
+            },
+        )

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/core/channel.py

@@ -7,6 +7,7 @@ from typing import Protocol
 from uuid import NAMESPACE_URL, uuid5
 
 from ..i18n import Translator
+from .audit import AuditRecorder
 from .lifecycle import IAsyncLifecycle
 from .models import (
     ApprovalRequest,
@@ -107,6 +108,7 @@ class ChannelContext:
     workspace: Callable[[], Path]
     translator: Translator | None = None
     timer_wheel: TimerWheel | None = None
+    audit: AuditRecorder | None = None
 
 
 class IApproval(Protocol):

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/core/orchestration/command.py

@@ -11,7 +11,7 @@ from dataclasses import replace
 from pathlib import Path, PurePosixPath
 
 from ..actor import Actor, Actors, Agent, Thread
-from ..audit import ErrorKind
+from ..audit import AuditRecorder, ErrorKind
 from ..channel import ChannelSendRequest
 from ..command import (
     ICommandService,
@@ -42,7 +42,7 @@ from ..storage import (
     ResolvedInboxTarget,
 )
 from .delivery import OutboundDeliveryService
-from .services import AuditRecorder, threads_in_reach
+from .services import threads_in_reach
 
 
 class OutboundAttachmentResolver:

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/core/orchestration/error_feedback.py

@@ -6,7 +6,7 @@ from collections.abc import Callable, Mapping
 from types import MappingProxyType
 
 from ...i18n import Translator
-from ..audit import ErrorKind
+from ..audit import AuditRecorder, ErrorKind
 from ..channel import ChannelSendRequest
 from ..correlation import CorrelationContext
 from ..models import (
@@ -19,7 +19,6 @@ from ..models import (
 from ..storage import IStorageScope
 from .delivery import OutboundDeliveryService
 from .reminder import resolve_reminder_anchor
-from .services import AuditRecorder
 
 MESSAGE_KEYS: Mapping[RuntimeTurnState, str] = MappingProxyType(
     {

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/core/orchestration/orchestrator.py

@@ -12,7 +12,7 @@ from ...i18n import Translator
 from ..actor import Actor, Actors
 from ..agent import Agent, State
 from ..approval import IApprovalHandler
-from ..audit import ErrorKind
+from ..audit import AuditRecorder, ErrorKind
 from ..channel import IChannel
 from ..concurrency import IThreadConcurrency, ThreadLockRegistry
 from ..correlation import CorrelationContext
@@ -27,7 +27,6 @@ from ..models import (
     RuntimeTurnState,
     Thread,
 )
-from ..observability import IAudit
 from ..outcomes import ProviderCallResult, ProviderCallStatus
 from ..runtime import (
     IRuntime,
@@ -50,7 +49,7 @@ from ..utils.text import format_exception
 from .command import CommandService
 from .delivery import OutboundDeliveryService
 from .error_feedback import MESSAGE_KEYS, RuntimeErrorReporter
-from .services import AuditRecorder, unread_in_reach
+from .services import unread_in_reach
 from .turn import (
     TurnContext,
     TurnCoordinator,
@@ -155,7 +154,7 @@ class AgentOrchestrator(IAsyncLifecycle):
         channel: IChannel,
         runtimes: Sequence[IRuntime],
         storage: IStorageScope,
-        audit: IAudit,
+        audit: AuditRecorder,
         timeout_budget: TimeoutBudget,
         timer_wheel: TimerWheel,
         runtime_idle_timeout_ms: int = 0,
@@ -195,11 +194,7 @@ class AgentOrchestrator(IAsyncLifecycle):
             self._logger.addHandler(logging.StreamHandler())
         self._logger.setLevel(logging.INFO)
         self._logger.propagate = False
-        self._audit = AuditRecorder(
-            sink=audit,
-            timeout_budget=timeout_budget,
-            clock=self._clock,
-        )
+        self._audit = audit
         self._agent = Agent(self._session_runtime_states)
         self._delivery = OutboundDeliveryService(
             channel,

bazaar_compute_node-0.2.0rc2/src/bazaar_compute_node/core/orchestration/services.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from ..actor import Actor, Agent, Thread
+from ..command import UnreadSummary
+from ..storage import IStorage
+
+
+async def threads_in_reach(storage: IStorage, actor: Actor) -> tuple[str, ...]:
+    """Return the conversations one actor answers for."""
+
+    match actor:
+        case Thread(thread_id):
+            return (thread_id,)
+        case Agent():
+            return await storage.list_thread_ids()
+
+
+async def unread_in_reach(
+    storage: IStorage,
+    actor: Actor,
+    *,
+    limit: int,
+) -> UnreadSummary:
+    """Say what one actor has unread, counted and carried from the same read."""
+
+    match actor:
+        case Thread(thread_id):
+            return await storage.read_unread_summary(thread_id, limit=limit)
+        case Agent():
+            return await storage.read_unread_summary(None, limit=limit)

{bazaar_compute_node-0.2.0rc1 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/core/orchestration/turn.py

@@ -13,7 +13,7 @@ from ..actor import Agent as AgentActor
 from ..actor import Thread as ThreadActor
 from ..agent import Agent, State
 from ..approval import ApprovalBinding, IApprovalHandler
-from ..audit import ErrorKind
+from ..audit import AuditRecorder, ErrorKind
 from ..channel import ChannelApprovalRequest, IChannel
 from ..concurrency import IThreadConcurrency
 from ..correlation import CorrelationContext
@@ -52,7 +52,6 @@ from ..models import (
 from ..runtime import IRuntimeTurnStream, Runtime, RuntimeSessionUnavailable
 from ..storage import IStorageScope
 from .reminder import resolve_reminder_anchor
-from .services import AuditRecorder
 
 
 def _is_turn_event(event_name: str) -> bool:

bazaar_compute_node-0.2.0rc1/src/bazaar_compute_node/contrib/telegram/plugin.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from ...core.channel import ChannelContext, IChannel, IChannelBuilder
-from .outbound import TelegramOutboundChannel
-
-
-class TelegramBuilder(IChannelBuilder):
-    def build(self, context: ChannelContext) -> IChannel:
-        token_env = context.options.get("token_env")
-        if not isinstance(token_env, str) or not token_env:
-            raise ValueError("agent.channel.token_env is required for telegram")
-        token = os.environ.get(token_env)
-        if token is None or not token.strip():
-            raise ValueError(f"telegram credential environment is missing: {token_env}")
-        return TelegramOutboundChannel(context, token=token)
-
-
-builder = TelegramBuilder()
-
-
-__all__ = ["TelegramBuilder", "builder"]

bazaar_compute_node-0.2.0rc1/src/bazaar_compute_node/core/audit.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from dataclasses import dataclass, field
-from enum import StrEnum
-
-from .correlation import CorrelationContext
-from .models import RuntimeEventState
-from .observability import LogLevel
-from .utils.sanitization import is_sensitive_field
-
-
-class ErrorKind(StrEnum):
-    CANCELLED = "cancelled"
-    TIMEOUT = "timeout"
-    VALIDATION = "validation"
-    SESSION_NOT_FOUND = "session_not_found"
-    TARGET_NOT_REPLYABLE = "target_not_replyable"
-    EMPTY_BODY = "empty_body"
-    FRESH_CHECK_REQUIRED = "fresh_check_required"
-    FRESH_CHECK_FAILED = "fresh_check_failed"
-    PROVIDER_FAILED = "provider_failed"
-    PROVIDER_PARTIAL = "provider_partial"
-    PROVIDER_UNKNOWN = "provider_unknown"
-    PROTOCOL = "protocol"
-    STORAGE = "storage"
-    SHUTDOWN_TIMEOUT = "shutdown_timeout"
-    INTERNAL = "internal"
-
-
-@dataclass(frozen=True, slots=True)
-class AuditEvent:
-    """Sanitized append-only event contract shared by all adapters."""
-
-    event_name: str
-    state: RuntimeEventState
-    created_at_ms: int
-    correlation: CorrelationContext
-    level: LogLevel = LogLevel.INFO
-    duration_ms: int | None = None
-    error_kind: ErrorKind | None = None
-    error_type: str | None = None
-    error_message: str | None = None
-    traceback_ref: str | None = None
-    metadata: Mapping[str, object] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        if self.error_kind is None and any(
-            value is not None
-            for value in (
-                self.error_type,
-                self.error_message,
-                self.traceback_ref,
-            )
-        ):
-            raise ValueError("error details require an error_kind")
-        pending: list[object] = [self.metadata]
-        while pending:
-            value = pending.pop()
-            if isinstance(value, Mapping):
-                for key, item in value.items():
-                    if not isinstance(key, str):
-                        raise TypeError("audit metadata keys must be strings")
-                    if is_sensitive_field(key):
-                        raise ValueError(
-                            f"audit metadata cannot contain sensitive field: {key}"
-                        )
-                    pending.append(item)
-            elif isinstance(value, list | tuple):
-                pending.extend(value)