agentirc-cli 8.1.0__tar.gz → 8.3.0__tar.gz

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [8.3.0] - 2026-04-25
+
+### Added
+
+- `irc.s2s.session` span over ServerLink connection lifetime.
+- `irc.s2s.<VERB>` per-verb spans on inbound federation messages with traceparent extraction and the inbound mitigation rules from `culture/protocol/extensions/tracing.md`.
+- `irc.s2s.relay` span on outbound relay enforcing the re-sign-per-hop rule.
+- `irc.client.session` span over Client connection lifetime (#290).
+- `irc.join` and `irc.part` spans (#290).
+- Public `culture.telemetry.context_from_traceparent` and `culture.telemetry.current_traceparent` helpers.
+- Single traceparent injection choke point at `ServerLink.send_raw`.
+- End-to-end propagation tests proving one `trace_id` spans federated client → server → relay → server hops.
+
+### Changed
+
+- `Client._dispatch` span name and `irc.command` attribute now uppercase, matching `ServerLink._dispatch` convention.
+
+### Fixed
+
+- `_replay_event` uses the hasattr-guarded comparison so string-typed federated `event.type` no longer skips the typed fast path. (#291)
+
+## [8.2.0] - 2026-04-24
+
+### Added
+
+- OpenTelemetry foundation: `culture/telemetry/` package with TracerProvider bootstrap, W3C trace context extract/inject helpers for IRCv3 tags, and `TelemetryConfig` block in `server.yaml`.
+- Protocol extension: `culture.dev/traceparent` and `culture.dev/tracestate` IRCv3 tags (`culture/protocol/extensions/tracing.md`).
+- Server-side tracing: `IRCd.emit_event`, `Client._dispatch`, `Client._process_buffer` (with parse-error compensation), and PRIVMSG dispatch/delivery paths now emit spans.
+- Outbound traceparent injection on `Client.send` and `Client.send_raw` when a span is active.
+- Operator docs at `docs/agentirc/telemetry.md` and starter collector config at `docs/agentirc/otelcol-template.yaml`; `docs/reference/server/config.md` documents the new `telemetry` block.
+- Dependencies: `opentelemetry-api`, `opentelemetry-sdk`, `opentelemetry-exporter-otlp-proto-grpc`, `opentelemetry-semantic-conventions`.
+
 ## [8.1.0] - 2026-04-23
 
 ### Added

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 8.1.0
+Version: 8.3.0
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum
@@ -18,6 +18,10 @@ Requires-Dist: aiohttp>=3.9
 Requires-Dist: anthropic>=0.40
 Requires-Dist: claude-agent-sdk>=0.1
 Requires-Dist: mistune>=3.0
+Requires-Dist: opentelemetry-api>=1.25
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.25
+Requires-Dist: opentelemetry-sdk>=1.25
+Requires-Dist: opentelemetry-semantic-conventions>=0.46b0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: textual>=1.0
 Provides-Extra: copilot

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/_config.culture.yml

@@ -36,6 +36,8 @@ aux_links:
     - "/agentirc/"
   "Agent Experience":
     - "https://culture.dev/agex/"
+  "Agent First Interop":
+    - "https://culture.dev/afi/"
   "Citation CLI":
     - "/citation-cli/"
   "GitHub":
@@ -49,5 +51,6 @@ footer_content: >-
   Inspectable CLI via <a href="/reference/cli/devex/">culture devex</a>
   (explain / overview / learn at every level).
   Agent Experience via <a href="https://culture.dev/agex/">agex-cli</a>.
+  Agent First Interop via <a href="https://culture.dev/afi/">afi-cli</a>.
   Code distribution via <a href="/citation-cli/">Citation CLI</a>.
   Source on <a href="https://github.com/agentculture/culture">GitHub</a>.

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/_data/sites.yml

@@ -1,3 +1,4 @@
+afi: https://culture.dev/afi/
 agentirc: https://culture.dev/agentirc/
 agex: https://culture.dev/agex/
 citation_cli: https://culture.dev/citation-cli/

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/_includes/head_custom.html

@@ -4,4 +4,5 @@
 <link rel="icon" type="image/png" sizes="16x16" href="{{ '/assets/images/favicon-16x16.png' | relative_url }}">
 <link rel="apple-touch-icon" sizes="180x180" href="{{ '/assets/images/apple-touch-icon.png' | relative_url }}">
 <link rel="related" href="{{ site.data.sites.agex }}" title="Agent Experience">
+<link rel="related" href="{{ site.data.sites.afi }}" title="Agent First Interop">
 <link rel="related" href="{{ site.data.sites.citation_cli }}" title="Citation CLI">

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/culture/agentirc/client.py

@@ -6,12 +6,34 @@ import logging
 import re
 from typing import TYPE_CHECKING
 
+from opentelemetry import trace as _otel_trace
+from opentelemetry.context import Context as _OtelContext
+from opentelemetry.trace import Span as _OtelSpan
+
 from culture.agentirc.channel import Channel
 from culture.agentirc.skill import Event, EventType
 from culture.aio import maybe_await
 from culture.constants import SYSTEM_USER_PREFIX
 from culture.protocol import replies
 from culture.protocol.message import Message
+from culture.telemetry.context import TRACEPARENT_TAG as _TP_TAG_NAME
+from culture.telemetry.context import (
+    context_from_traceparent,
+    current_traceparent,
+    extract_traceparent_from_tags,
+)
+from culture.telemetry.context import inject_traceparent as _inject_traceparent
+
+# OTEL instrumentation name (must match `_CULTURE_TRACER_NAME` in
+# culture/telemetry/tracing.py so trace consumers see one consistent value).
+_TRACER_NAME = "culture.agentirc"
+# Span attribute keys, defined once so a future rename / sanitization layer
+# has one edit point.
+_ATTR_BODY = "irc.message.body"
+_ATTR_SIZE = "irc.message.size"
+_ATTR_NICK = "irc.client.nick"
+_ATTR_CHANNEL = "irc.channel"
+
 
 if TYPE_CHECKING:
     from culture.agentirc.ircd import IRCd
@@ -39,12 +61,21 @@ class Client:
         self.caps: set[str] = set()
         self.modes: set[str] = set()
         self.icon: str | None = None
+        self._session_span: _OtelSpan | None = None
 
     @property
     def prefix(self) -> str:
         return f"{self.nick}!{self.user}@{self.host}"
 
     async def send(self, message: Message) -> None:
+        # Only inject trace context for clients that negotiated IRCv3
+        # message-tags; otherwise older clients would see an unexpected @-tag
+        # block and `send_tagged`'s tag-stripping for non-capable clients
+        # would be undone here.
+        if "message-tags" in self.caps:
+            tp = current_traceparent()
+            if tp is not None:
+                _inject_traceparent(message, traceparent=tp, tracestate=None)
         try:
             self.writer.write(message.format().encode("utf-8"))
             await self.writer.drain()
@@ -55,7 +86,15 @@ class Client:
         """Write a pre-formatted IRC line to the client socket.
 
         Appends CRLF internally, matching ServerLink.send_raw convention.
+        Injects `culture.dev/traceparent` as an IRCv3 tag when a span is active
+        AND the client negotiated the `message-tags` capability.
         """
+        if "message-tags" in self.caps:
+            tp = current_traceparent()
+            if tp is not None:
+                # send_raw takes a pre-formatted line without an existing tag
+                # block; prefix a fresh @tag.
+                line = f"@{_TP_TAG_NAME}={tp} {line}"
         try:
             self.writer.write(f"{line}\r\n".encode("utf-8"))
             await self.writer.drain()
@@ -84,46 +123,94 @@ class Client:
 
     async def _process_buffer(self, buffer: str) -> str:
         """Parse and dispatch all complete lines from buffer, return remainder."""
-        while "\n" in buffer:
-            line, buffer = buffer.split("\n", 1)
-            if line.strip():
-                msg = Message.parse(line)
+        # Per-call get_tracer: test fixture swaps provider between tests.
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.client.process_buffer"
+        ) as span:
+            while "\n" in buffer:
+                line, buffer = buffer.split("\n", 1)
+                if not line.strip():
+                    continue
+                try:
+                    msg = Message.parse(line)
+                except Exception as exc:  # noqa: BLE001 -- widen for any parser failure
+                    span.add_event(
+                        "irc.parse_error",
+                        attributes={
+                            "line_preview": line[:64],
+                            "error": type(exc).__name__,
+                        },
+                    )
+                    continue
                 if msg.command:
                     await self._dispatch(msg)
-        return buffer
+            return buffer
 
     async def handle(self, initial_msg: str | None = None) -> None:
-        buffer = ""
-        if initial_msg:
-            buffer = initial_msg.replace("\r\n", "\n").replace("\r", "\n")
-            buffer = await self._process_buffer(buffer)
-        while True:
-            data = await self.reader.read(4096)
-            if not data:
-                break
-            buffer += data.decode("utf-8", errors="replace")
-            # Cap buffer to prevent unbounded memory growth (512 bytes per RFC 2812)
-            if len(buffer) > 8192:
-                buffer = buffer[-4096:]
-            # Normalize all line endings to \n for simpler parsing
-            buffer = buffer.replace("\r\n", "\n").replace("\r", "\n")
-            buffer = await self._process_buffer(buffer)
+        peer_info = self.writer.get_extra_info("peername")
+        remote_addr = f"{peer_info[0]}:{peer_info[1]}" if peer_info else ""
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.client.session",
+            attributes={"irc.client.remote_addr": remote_addr},
+        ) as span:
+            self._session_span = span
+            try:
+                buffer = ""
+                if initial_msg:
+                    buffer = initial_msg.replace("\r\n", "\n").replace("\r", "\n")
+                    buffer = await self._process_buffer(buffer)
+                while True:
+                    data = await self.reader.read(4096)
+                    if not data:
+                        break
+                    buffer += data.decode("utf-8", errors="replace")
+                    # Cap buffer to prevent unbounded memory growth (512 bytes per RFC 2812)
+                    if len(buffer) > 8192:
+                        buffer = buffer[-4096:]
+                    # Normalize all line endings to \n for simpler parsing
+                    buffer = buffer.replace("\r\n", "\n").replace("\r", "\n")
+                    buffer = await self._process_buffer(buffer)
+            except (ConnectionError, asyncio.IncompleteReadError):
+                pass
 
     async def _dispatch(self, msg: Message) -> None:
-        handler = getattr(self, f"_handle_{msg.command.lower()}", None)
-        if handler:
-            await maybe_await(handler(msg))
+        extract = extract_traceparent_from_tags(msg, peer=None)
+        if extract.status == "valid":
+            parent_ctx: _OtelContext | None = context_from_traceparent(extract.traceparent)
         else:
-            skill = self.server.get_skill_for_command(msg.command)
-            if skill and self._registered:
-                try:
-                    await skill.on_command(self, msg)
-                except Exception:
-                    logging.getLogger(__name__).exception(
-                        "Skill %s failed on command %s", skill.name, msg.command
-                    )
+            parent_ctx = _OtelContext()  # force root: detach from session span
+
+        verb = msg.command.upper()
+        attrs = {
+            "irc.command": verb,
+            "irc.prefix_nick": (msg.prefix.split("!")[0] if msg.prefix else ""),
+            "culture.trace.origin": "local" if extract.status == "missing" else "remote",
+        }
+        if extract.status in ("malformed", "too_long"):
+            attrs["culture.trace.dropped_reason"] = extract.status
+
+        # Per-call get_tracer: test fixture swaps provider between tests.
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            f"irc.command.{verb}",
+            context=parent_ctx,
+            attributes=attrs,
+        ):
+            handler = getattr(self, f"_handle_{msg.command.lower()}", None)
+            if handler:
+                await maybe_await(handler(msg))
             else:
-                await self.send_numeric(replies.ERR_UNKNOWNCOMMAND, msg.command, "Unknown command")
+                skill = self.server.get_skill_for_command(msg.command)
+                if skill and self._registered:
+                    try:
+                        await skill.on_command(self, msg)
+                    except Exception:
+                        logging.getLogger(__name__).exception(
+                            "Skill %s failed on command %s", skill.name, msg.command
+                        )
+                else:
+                    await self.send_numeric(
+                        replies.ERR_UNKNOWNCOMMAND, msg.command, "Unknown command"
+                    )
 
     async def _handle_ping(self, msg: Message) -> None:
         token = msg.params[0] if msg.params else ""
@@ -205,6 +292,8 @@ class Client:
 
         self.nick = nick
         self.server.clients[nick] = self
+        if self._session_span is not None:
+            self._session_span.set_attribute(_ATTR_NICK, nick)
         await self._try_register()
 
     async def _handle_user(self, msg: Message) -> None:
@@ -256,45 +345,49 @@ class Client:
             return
 
         channel_name = msg.params[0]
-        if not channel_name.startswith("#"):
-            return
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.join",
+            attributes={_ATTR_CHANNEL: channel_name, _ATTR_NICK: self.nick or ""},
+        ):
+            if not channel_name.startswith("#"):
+                return
 
-        # Block joins to archived rooms
-        existing = self.server.channels.get(channel_name)
-        if existing and existing.archived:
-            await self.send(
-                Message(
-                    prefix=self.server.config.name,
-                    command="NOTICE",
-                    params=[self.nick, f"{channel_name} is archived and cannot be joined"],
+            # Block joins to archived rooms
+            existing = self.server.channels.get(channel_name)
+            if existing and existing.archived:
+                await self.send(
+                    Message(
+                        prefix=self.server.config.name,
+                        command="NOTICE",
+                        params=[self.nick, f"{channel_name} is archived and cannot be joined"],
+                    )
                 )
-            )
-            return
+                return
 
-        channel = self.server.get_or_create_channel(channel_name)
-        if self in channel.members:
-            return
+            channel = self.server.get_or_create_channel(channel_name)
+            if self in channel.members:
+                return
 
-        channel.add(self)
-        self.channels.add(channel)
+            channel.add(self)
+            self.channels.add(channel)
 
-        # Notify all channel members (including self)
-        join_msg = Message(prefix=self.prefix, command="JOIN", params=[channel_name])
-        for member in list(channel.members):
-            await member.send(join_msg)
+            # Notify all channel members (including self)
+            join_msg = Message(prefix=self.prefix, command="JOIN", params=[channel_name])
+            for member in list(channel.members):
+                await member.send(join_msg)
 
-        # Send topic if set
-        if channel.topic:
-            await self.send_numeric(replies.RPL_TOPIC, channel_name, channel.topic)
+            # Send topic if set
+            if channel.topic:
+                await self.send_numeric(replies.RPL_TOPIC, channel_name, channel.topic)
 
-        # Send names list
-        await self._send_names(channel)
+            # Send names list
+            await self._send_names(channel)
 
-        # Emit event AFTER delivering all join-related numerics (topic, NAMES)
-        # so that the event PRIVMSG doesn't interleave with 353/366 in client buffers.
-        await self.server.emit_event(
-            Event(type=EventType.JOIN, channel=channel_name, nick=self.nick)
-        )
+            # Emit event AFTER delivering all join-related numerics (topic, NAMES)
+            # so that the event PRIVMSG doesn't interleave with 353/366 in client buffers.
+            await self.server.emit_event(
+                Event(type=EventType.JOIN, channel=channel_name, nick=self.nick)
+            )
 
     async def _handle_part(self, msg: Message) -> None:
         if not msg.params:
@@ -302,36 +395,40 @@ class Client:
             return
 
         channel_name = msg.params[0]
-        reason = msg.params[1] if len(msg.params) > 1 else ""
-
-        channel = self.server.channels.get(channel_name)
-        if not channel or self not in channel.members:
-            await self.send_numeric(
-                replies.ERR_NOTONCHANNEL,
-                channel_name,
-                replies.MSG_NOTONCHANNEL,
-            )
-            return
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.part",
+            attributes={_ATTR_CHANNEL: channel_name, _ATTR_NICK: self.nick or ""},
+        ):
+            reason = msg.params[1] if len(msg.params) > 1 else ""
+
+            channel = self.server.channels.get(channel_name)
+            if not channel or self not in channel.members:
+                await self.send_numeric(
+                    replies.ERR_NOTONCHANNEL,
+                    channel_name,
+                    replies.MSG_NOTONCHANNEL,
+                )
+                return
 
-        part_params = [channel_name, reason] if reason else [channel_name]
-        part_msg = Message(prefix=self.prefix, command="PART", params=part_params)
-        for member in list(channel.members):
-            await member.send(part_msg)
+            part_params = [channel_name, reason] if reason else [channel_name]
+            part_msg = Message(prefix=self.prefix, command="PART", params=part_params)
+            for member in list(channel.members):
+                await member.send(part_msg)
 
-        await self.server.emit_event(
-            Event(
-                type=EventType.PART,
-                channel=channel_name,
-                nick=self.nick,
-                data={"reason": reason},
+            await self.server.emit_event(
+                Event(
+                    type=EventType.PART,
+                    channel=channel_name,
+                    nick=self.nick,
+                    data={"reason": reason},
+                )
             )
-        )
 
-        channel.remove(self)
-        self.channels.discard(channel)
+            channel.remove(self)
+            self.channels.discard(channel)
 
-        if not channel.members and not channel.persistent:
-            del self.server.channels[channel_name]
+            if not channel.members and not channel.persistent:
+                del self.server.channels[channel_name]
 
     async def _handle_topic(self, msg: Message) -> None:
         if not msg.params:
@@ -615,46 +712,64 @@ class Client:
         await self.send_numeric(replies.RPL_UMODEIS, mode_str)
 
     async def _send_to_channel(self, channel, target, relay, text, is_notice):
-        for member in list(channel.members):
-            if member is not self:
-                await member.send(relay)
-        event_data = {"text": text}
-        if is_notice:
-            event_data["notice"] = True
-        await self.server.emit_event(
-            Event(
-                type=EventType.MESSAGE,
-                channel=target,
-                nick=self.nick,
-                data=event_data,
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.privmsg.deliver.channel",
+            attributes={
+                "irc.channel": target,
+                _ATTR_BODY: text,
+                _ATTR_SIZE: len(text),
+                "irc.notice": is_notice,
+            },
+        ):
+            for member in list(channel.members):
+                if member is not self:
+                    await member.send(relay)
+            event_data = {"text": text}
+            if is_notice:
+                event_data["notice"] = True
+            await self.server.emit_event(
+                Event(
+                    type=EventType.MESSAGE,
+                    channel=target,
+                    nick=self.nick,
+                    data=event_data,
+                )
             )
-        )
 
     async def _send_to_client(self, target, relay, text, is_notice):
         from culture.agentirc.remote_client import RemoteClient
 
-        recipient = self.server.get_client(target)
-        if not recipient:
-            return False
-        if isinstance(recipient, RemoteClient):
-            s2s_cmd = "SNOTICE" if is_notice else "SMSG"
-            await recipient.link.send_raw(
-                f":{self.server.config.name} {s2s_cmd} {target} {self.nick} :{text}"
-            )
-        else:
-            await recipient.send(relay)
-        event_data = {"text": text, "target": target}
-        if is_notice:
-            event_data["notice"] = True
-        await self.server.emit_event(
-            Event(
-                type=EventType.MESSAGE,
-                channel=None,
-                nick=self.nick,
-                data=event_data,
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.privmsg.deliver.dm",
+            attributes={
+                "irc.target.nick": target,
+                _ATTR_BODY: text,
+                _ATTR_SIZE: len(text),
+                "irc.notice": is_notice,
+            },
+        ):
+            recipient = self.server.get_client(target)
+            if not recipient:
+                return False
+            if isinstance(recipient, RemoteClient):
+                s2s_cmd = "SNOTICE" if is_notice else "SMSG"
+                await recipient.link.send_raw(
+                    f":{self.server.config.name} {s2s_cmd} {target} {self.nick} :{text}"
+                )
+            else:
+                await recipient.send(relay)
+            event_data = {"text": text, "target": target}
+            if is_notice:
+                event_data["notice"] = True
+            await self.server.emit_event(
+                Event(
+                    type=EventType.MESSAGE,
+                    channel=None,
+                    nick=self.nick,
+                    data=event_data,
+                )
             )
-        )
-        return True
+            return True
 
     async def _handle_privmsg(self, msg: Message) -> None:
         if len(msg.params) < 2:
@@ -665,28 +780,37 @@ class Client:
 
         target = msg.params[0]
         text = msg.params[1]
-        relay = Message(prefix=self.prefix, command="PRIVMSG", params=[target, text])
-
-        if target.startswith("#"):
-            channel = self.server.channels.get(target)
-            if not channel:
-                await self.send_numeric(
-                    replies.ERR_NOSUCHCHANNEL, target, replies.MSG_NOSUCHCHANNEL
-                )
-                return
-            if self not in channel.members:
-                await self.send_numeric(
-                    replies.ERR_CANNOTSENDTOCHAN, target, "Cannot send to channel"
-                )
-                return
-            await self._send_to_channel(channel, target, relay, text, False)
-            await self._notify_mentions(target, text)
-        else:
-            found = await self._send_to_client(target, relay, text, False)
-            if not found:
-                await self.send_numeric(replies.ERR_NOSUCHNICK, target, replies.MSG_NOSUCHNICK)
-                return
-            await self._notify_mentions(None, text)
+        # Per-call get_tracer: test fixture swaps provider between tests.
+        with _otel_trace.get_tracer(_TRACER_NAME).start_as_current_span(
+            "irc.privmsg.dispatch",
+            attributes={
+                "irc.target": target,
+                _ATTR_BODY: text,
+                _ATTR_SIZE: len(text),
+            },
+        ):
+            relay = Message(prefix=self.prefix, command="PRIVMSG", params=[target, text])
+
+            if target.startswith("#"):
+                channel = self.server.channels.get(target)
+                if not channel:
+                    await self.send_numeric(
+                        replies.ERR_NOSUCHCHANNEL, target, replies.MSG_NOSUCHCHANNEL
+                    )
+                    return
+                if self not in channel.members:
+                    await self.send_numeric(
+                        replies.ERR_CANNOTSENDTOCHAN, target, "Cannot send to channel"
+                    )
+                    return
+                await self._send_to_channel(channel, target, relay, text, False)
+                await self._notify_mentions(target, text)
+            else:
+                found = await self._send_to_client(target, relay, text, False)
+                if not found:
+                    await self.send_numeric(replies.ERR_NOSUCHNICK, target, replies.MSG_NOSUCHNICK)
+                    return
+                await self._notify_mentions(None, text)
 
     async def _notify_mentions(self, channel_name: str | None, text: str) -> None:
         from culture.agentirc.remote_client import RemoteClient

{agentirc_cli-8.1.0 → agentirc_cli-8.3.0}/culture/agentirc/config.py

@@ -12,6 +12,20 @@ class LinkConfig:
     trust: str = "full"  # "full" or "restricted"
 
 
+@dataclass
+class TelemetryConfig:
+    """OpenTelemetry settings. Mirrors server.yaml `telemetry:` block."""
+
+    enabled: bool = False
+    service_name: str = "culture.agentirc"
+    otlp_endpoint: str = "http://localhost:4317"
+    otlp_protocol: str = "grpc"  # grpc | http/protobuf (only grpc supported initially)
+    otlp_timeout_ms: int = 5000
+    otlp_compression: str = "gzip"  # gzip | none
+    traces_enabled: bool = True
+    traces_sampler: str = "parentbased_always_on"
+
+
 @dataclass
 class ServerConfig:
     """Configuration for a culture server instance."""
@@ -23,3 +37,4 @@ class ServerConfig:
     data_dir: str = ""
     links: list[LinkConfig] = field(default_factory=list)
     system_bots: dict = field(default_factory=dict)
+    telemetry: TelemetryConfig = field(default_factory=TelemetryConfig)