bazaar-compute-node 0.2.0rc5__tar.gz → 0.2.1rc2__tar.gz

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/PKG-INFO

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

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/pyproject.toml

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

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

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

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

@@ -14,7 +14,7 @@ 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.channel import Channel, ChannelContext, Channels, IChannel
 from ..core.concurrency import IThreadConcurrency, ThreadLockRegistry
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -111,18 +111,25 @@ class AgentApplication:
             timeout_budget=timeout_budget,
             clock=now_ms,
         )
-        provider_channel = factories.channel.build(
-            ChannelContext(
-                agent_id=self.agent_id,
-                attachments=self._attachment_materializer,
-                options=dict(configuration.channel.options),
-                workspace=self.workspace_path,
-                translator=self.translator,
-                timer_wheel=self.timer_wheel,
-                audit=self._audit_recorder,
+        self.channel: IChannel = Channels(
+            tuple(
+                Channel(
+                    self.agent_id,
+                    factories.channels[channel_configuration.kind].build(
+                        ChannelContext(
+                            agent_id=self.agent_id,
+                            attachments=self._attachment_materializer,
+                            options=dict(channel_configuration.options),
+                            workspace=self.workspace_path,
+                            translator=self.translator,
+                            timer_wheel=self.timer_wheel,
+                            audit=self._audit_recorder,
+                        )
+                    ),
+                )
+                for channel_configuration in configuration.channels
             )
         )
-        self.channel: IChannel = Channel(self.agent_id, provider_channel)
         runtime_contexts: list[RuntimeCommandContext] = []
         runtimes: list[IRuntime] = []
         for index, runtime_configuration in enumerate(configuration.runtimes):
@@ -142,7 +149,7 @@ class AgentApplication:
                 environment_for_session=partial(self._runtime_environment, index),
                 agent_id=self.agent_id,
                 agent_name=self.name,
-                bot_name=self._bot_name,
+                bot_names=self._bot_names,
                 runtime_options=runtime_options,
                 mode=configuration.mode,
                 sandbox_mode=runtime_configuration.sandbox_mode,
@@ -194,7 +201,6 @@ class AgentApplication:
             self.orchestrator.command_service,
             actors=self._actors,
             reminder_service=self.reminder_service,
-            timeout_budget=self.timeout_budget,
             session_binding_validator=self._validate_actor_binding,
             upgrade_service=upgrade_service,
         )
@@ -228,6 +234,7 @@ class AgentApplication:
                 mode=self._actors.mode,
             )
             await self._attachment_materializer.reconcile()
+            await self._backfill_channel_identity()
             await self.orchestrator.start(
                 timeout=self.timeout_budget.startup_seconds,
             )
@@ -237,14 +244,38 @@ class AgentApplication:
         self._started = True
         self.command_dispatcher.start_accepting()
 
-    def _bot_name(self) -> str | None:
-        identity = self.channel.get_identity()
-        if identity is not None:
-            if identity.name is not None:
-                return identity.name
-            if identity.id is not None:
-                return identity.id
-        return None
+    async def _backfill_channel_identity(self) -> None:
+        """Give conversations written before bots were told apart to this one.
+
+        Only a channel that knows its bot before it starts can do this here;
+        the kinds that carry the bot in the thread id were filled by migration.
+        A kind with several bots hands them to the first, in configuration
+        order.
+        """
+
+        for member in self.channel.members:
+            identity = member.get_identity()
+            if identity is None:
+                continue
+            for session in await self.storage.list_channel_sessions_without_identity(
+                member.name
+            ):
+                await self.storage.backfill_channel_identity(
+                    session.id,
+                    channel_identity=identity.id,
+                    provider_thread_id=member.backfill_provider_thread_id(
+                        session.provider_thread_id
+                    ),
+                )
+
+    def _bot_names(self) -> tuple[str, ...]:
+        names: dict[str, None] = {}
+        for member in self.channel.members:
+            identity = member.get_identity()
+            if identity is None:
+                continue
+            names[identity.name or identity.id] = None
+        return tuple(names)
 
     async def stop(self) -> None:
         if self._stopping:
@@ -291,7 +322,7 @@ class AgentApplication:
             "agent_id": self.agent_id,
             "name": self.name,
             "status": "started" if self.started else "stopped",
-            "channel": self.channel.name,
+            "channels": tuple(member.name for member in self.channel.members),
             "runtimes": tuple(runtime.name for runtime in self.runtimes),
             "channel_health": dict(self.channel.health),
             "orchestrator_health": self.orchestrator.health,

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/src/bazaar_compute_node/app/agent_management.py

@@ -101,7 +101,7 @@ def _list_agents(configuration: NodeConfiguration) -> int:
     for agent in configuration.agents:
         print(
             f"id={agent.id} name={agent.name} "
-            f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
+            f"channel={_channel_kinds(agent)} runtime={_runtime_kinds(agent)}",
             flush=True,
         )
     return 0
@@ -123,9 +123,11 @@ def _add_agent(
         agent = AgentConfiguration(
             id=str(uuid7()),
             name=args.name,
-            channel=ChannelConfiguration(
-                kind=args.channel,
-                options=MappingProxyType(options.channel),
+            channels=(
+                ChannelConfiguration(
+                    kind=args.channel,
+                    options=MappingProxyType(options.channel),
+                ),
             ),
             runtimes=(_runtime_configuration(args.runtime, options, parser),),
             idle_timeout_seconds=idle_timeout,
@@ -139,7 +141,7 @@ def _add_agent(
         parser.error(str(error))
     print(
         f"Agent added id={agent.id} name={agent.name} "
-        f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
+        f"channel={_channel_kinds(agent)} runtime={_runtime_kinds(agent)}",
         flush=True,
     )
     print("Run `bcn restart` to apply.", flush=True)
@@ -206,6 +208,10 @@ def run_agent_command(
             raise AssertionError(f"unsupported Agent command: {unsupported}")
 
 
+def _channel_kinds(agent: AgentConfiguration) -> str:
+    return ",".join(channel.kind for channel in agent.channels)
+
+
 def _runtime_kinds(agent: AgentConfiguration) -> str:
     return ",".join(runtime.kind for runtime in agent.runtimes)
 

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/src/bazaar_compute_node/app/application.py

@@ -33,7 +33,7 @@ from .version_check import VersionWatcher
 class AgentStartupResult:
     agent_id: str
     name: str
-    channel: str
+    channels: tuple[str, ...]
     runtimes: tuple[str, ...]
     status: str
     error_type: str | None = None
@@ -44,7 +44,7 @@ class AgentStartupResult:
             "agent_id": self.agent_id,
             "name": self.name,
             "status": self.status,
-            "channel": self.channel,
+            "channels": self.channels,
             "runtimes": self.runtimes,
         }
         if self.error_type is not None:
@@ -54,6 +54,10 @@ class AgentStartupResult:
         return record
 
 
+def _channel_kinds(configuration: AgentConfiguration) -> tuple[str, ...]:
+    return tuple(channel.kind for channel in configuration.channels)
+
+
 def _runtime_kinds(configuration: AgentConfiguration) -> tuple[str, ...]:
     return tuple(runtime.kind for runtime in configuration.runtimes)
 
@@ -182,7 +186,7 @@ class NodeApplication:
             async with asyncio.timeout(self.timeout_budget.startup_seconds):
                 factories = await asyncio.to_thread(
                     self._registry.load_agent,
-                    channel=configuration.channel.kind,
+                    channels=_channel_kinds(configuration),
                     runtimes=_runtime_kinds(configuration),
                 )
                 storage_scope = self.storage.scope(configuration.id, configuration.name)
@@ -211,7 +215,7 @@ class NodeApplication:
             result = AgentStartupResult(
                 agent_id=configuration.id,
                 name=configuration.name,
-                channel=configuration.channel.kind,
+                channels=_channel_kinds(configuration),
                 runtimes=_runtime_kinds(configuration),
                 status="failed",
                 error_type=type(error).__name__,
@@ -225,7 +229,7 @@ class NodeApplication:
         result = AgentStartupResult(
             agent_id=configuration.id,
             name=configuration.name,
-            channel=configuration.channel.kind,
+            channels=_channel_kinds(configuration),
             runtimes=_runtime_kinds(configuration),
             status="started",
         )
@@ -438,7 +442,7 @@ class NodeApplication:
                     "agent_id": configuration.id,
                     "name": configuration.name,
                     "status": "pending",
-                    "channel": configuration.channel.kind,
+                    "channels": _channel_kinds(configuration),
                     "runtimes": _runtime_kinds(configuration),
                 }
             )

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/src/bazaar_compute_node/app/command.py

@@ -20,11 +20,12 @@ from pydantic import (
 from ..core.actor import Actor, Actors
 from ..core.command import (
     ICommandService,
+    MessageBroadcast,
     MessageSendFreshnessHold,
+    MessageSendSuccess,
     TargetProjection,
     ThreadNotFoundError,
 )
-from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
     InboundAttachment,
     InboxTargetSummary,
@@ -210,7 +211,6 @@ class _MessageSendRequest(_CommandRequest):
     command: Literal["send"]
     target: NonEmptyText
     body: StrictStr
-    command_id: NonEmptyText
     attachment_paths: list[NonEmptyText] = Field(default_factory=list)
     reply_to_message_id: NonEmptyText | None = None
     send_draft: StrictBool = False
@@ -240,6 +240,16 @@ _REQUEST_MODELS: dict[tuple[str, str], _RequestModel] = {
     ("thread", "unfollow"): _ThreadUnfollowRequest,
 }
 
+# the states in which some of the message is with the peer, which is when
+# a resend would put it there twice
+_REACHED_STATES = frozenset(
+    {
+        OutboundDeliveryState.SENT,
+        OutboundDeliveryState.QUEUED,
+        OutboundDeliveryState.PARTIAL,
+    }
+)
+
 _SEND_FAILURES: dict[OutboundDeliveryState, tuple[str, str, str]] = {
     OutboundDeliveryState.PARTIAL: (
         "SEND_PARTIAL",
@@ -271,10 +281,6 @@ _REQUEST_ERRORS: dict[str, tuple[str, str]] = {
         "around_message_id must be a string",
     ),
     "body": ("BODY_REQUIRED", "body must be text"),
-    "command_id": (
-        "COMMAND_ID_REQUIRED",
-        "command_id must be a non-empty string",
-    ),
     "attachment_paths": (
         "INVALID_ATTACHMENTS",
         "attachment_paths must be a list of non-empty strings",
@@ -328,12 +334,10 @@ class CommandDispatcher:
         service: ICommandService,
         *,
         actors: Actors,
-        timeout_budget: TimeoutBudget,
         session_binding_validator: SessionBindingValidator | None = None,
     ) -> None:
         self._actors = actors
         self._service = service
-        self._timeout_budget = timeout_budget
         self._session_binding_validator = session_binding_validator
         self._accepting = False
         self._in_flight: set[asyncio.Task[object]] = set()
@@ -381,10 +385,6 @@ class CommandDispatcher:
         if pending:
             await asyncio.gather(*pending, return_exceptions=True)
 
-    def _command_timeout(self, request: Mapping[str, object]) -> float | None:
-        del request
-        return self._timeout_budget.command_seconds
-
     async def __call__(self, request: Mapping[str, object]) -> Mapping[str, object]:
         if not self._accepting:
             return {
@@ -398,9 +398,10 @@ class CommandDispatcher:
             self._drained.clear()
         try:
             kind = request.get("kind")
+            # a command takes as long as its work takes: giving up on one
+            # whose work carries on regardless only hides what became of it
             if kind == "command":
-                async with asyncio.timeout(self._command_timeout(request)):
-                    return await self._dispatch_command(request)
+                return await self._dispatch_command(request)
             raise CommandDispatchError(
                 "INVALID_COMMAND", "request kind is not supported"
             )
@@ -561,7 +562,6 @@ class CommandDispatcher:
     ) -> Mapping[str, object]:
         result = await self._service.send(
             actor=actor,
-            command_id=request.command_id,
             raw_target=request.target,
             body=request.body,
             created_at_ms=request.created_at_ms,
@@ -571,33 +571,35 @@ class CommandDispatcher:
         )
         if isinstance(result, MessageSendFreshnessHold):
             return {"ok": True, "result": {"text": format_freshness_hold(result)}}
-        message = result.message
-        delivery_state = message.delivery_state
-        if delivery_state is None:
-            raise RuntimeError("outbound message has no delivery state")
-        if delivery_state not in {
-            OutboundDeliveryState.SENT,
-            OutboundDeliveryState.QUEUED,
-        }:
-            failure = _SEND_FAILURES.get(delivery_state)
-            if failure is None:
-                raise AssertionError(
-                    f"message send returned unsupported state: {delivery_state.value}"
-                )
-            code, fallback, next_action = failure
+        # the handle may have named one peer on several bots; to the caller
+        # that is one conversation, so it hears about one delivery, and a
+        # failure on any of them is the answer for all
+        sent = result.deliveries if isinstance(result, MessageBroadcast) else (result,)
+        reached: list[str] = []
+        failure: CommandDispatchError | None = None
+        for delivery in sent:
+            refused = _send_failure(delivery)
+            if refused is not None and failure is None:
+                failure = refused
+            if delivery.message.delivery_state in _REACHED_STATES:
+                reached.append(delivery.target)
+        if failure is None:
+            return {"ok": True, "result": {"text": _format_send_success(sent[0])}}
+        if reached:
+            # a resend would reach these again, so the caller is told which
             raise CommandDispatchError(
-                code,
-                message.error_message or fallback,
-                next_action=next_action,
+                failure.code,
+                f"{failure.message} Already reached {', '.join(reached)}.",
+                next_action=" ".join(
+                    part
+                    for part in (
+                        failure.next_action,
+                        "A resend reaches the conversations already reached again.",
+                    )
+                    if part is not None
+                ),
             )
-        text = _SEND_RESULT.render(
-            {
-                "delivery_state": delivery_state.value,
-                "target": result.target,
-                "message_id": message.message_id,
-            }
-        )
-        return {"ok": True, "result": {"text": text}}
+        raise failure
 
     async def _unfollow_thread(
         self, actor: Actor, request: _ThreadUnfollowRequest
@@ -621,6 +623,42 @@ _ATTACHMENT_SUFFIX = TextTemplate.from_resource("command/attachment_suffix.tpl")
 _SENDER = TextTemplate.from_resource("command/sender.tpl")
 _CHECK_MESSAGE = TextTemplate.from_resource("command/check_message.tpl")
 _READ_MESSAGE = TextTemplate.from_resource("command/read_message.tpl")
+
+
+def _send_failure(result: MessageSendSuccess) -> CommandDispatchError | None:
+    message = result.message
+    delivery_state = message.delivery_state
+    if delivery_state is None:
+        raise RuntimeError("outbound message has no delivery state")
+    if delivery_state in {OutboundDeliveryState.SENT, OutboundDeliveryState.QUEUED}:
+        return None
+    failure = _SEND_FAILURES.get(delivery_state)
+    if failure is None:
+        raise AssertionError(
+            f"message send returned unsupported state: {delivery_state.value}"
+        )
+    code, fallback, next_action = failure
+    return CommandDispatchError(
+        code,
+        message.error_message or fallback,
+        next_action=next_action,
+    )
+
+
+def _format_send_success(result: MessageSendSuccess) -> str:
+    message = result.message
+    delivery_state = message.delivery_state
+    if delivery_state is None:
+        raise RuntimeError("outbound message has no delivery state")
+    return _SEND_RESULT.render(
+        {
+            "delivery_state": delivery_state.value,
+            "target": result.target,
+            "message_id": message.message_id,
+        }
+    )
+
+
 _SEND_RESULT = TextTemplate.from_resource("command/send_result.tpl")
 _FRESHNESS_HOLD = TextTemplate.from_resource("command/freshness_hold.tpl")
 

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/src/bazaar_compute_node/app/config.py

@@ -17,7 +17,7 @@ from ..core.paths import resolve_data_dir
 from ..core.runtime import RuntimeSandboxMode
 
 CONFIG_FILENAME = "config.toml"
-CONFIG_VERSION = "3"
+CONFIG_VERSION = "4"
 DEFAULT_AUDIT = "logging"
 DEFAULT_STORAGE = "sqlite"
 DEFAULT_DATABASE_FILENAME = "bcn.sqlite3"
@@ -68,7 +68,7 @@ class RuntimeConfiguration:
 class AgentConfiguration:
     id: str
     name: str
-    channel: ChannelConfiguration
+    channels: tuple[ChannelConfiguration, ...]
     runtimes: tuple[RuntimeConfiguration, ...]
     mode: Mode = Mode.SESSION
     idle_timeout_seconds: float = 0
@@ -76,6 +76,8 @@ class AgentConfiguration:
     def __post_init__(self) -> None:
         _validate_agent_id(self.id, "agent.id")
         _required_text(self.name, "agent.name")
+        if not self.channels:
+            raise ConfigurationError("agent.channel must define at least one channel")
         if not self.runtimes:
             raise ConfigurationError("agent.runtime must define at least one runtime")
         if (
@@ -91,7 +93,7 @@ class AgentConfiguration:
 
 @dataclass(frozen=True, slots=True)
 class NodeConfiguration:
-    """Version 3 persistent node configuration."""
+    """Version 4 persistent node configuration."""
 
     agents: tuple[AgentConfiguration, ...] = ()
     storage: str = DEFAULT_STORAGE
@@ -173,15 +175,15 @@ def resolve_config_path() -> Path:
 def load_node_configuration(
     path: Path | None = None,
 ) -> NodeConfiguration:
-    """Load v3 configuration, advancing older input through the upgrade states."""
+    """Load v4 configuration, advancing older input through the upgrade states."""
 
     path = (path or resolve_config_path()).expanduser()
     payload = _read_configuration(path)
     state = _configuration_state(_payload_version(payload))
     if state.is_current:
-        return _parse_v3_configuration(payload)
+        return _parse_v4_configuration(payload)
 
-    configuration = _parse_v3_configuration(state.advance(payload))
+    configuration = _parse_v4_configuration(state.advance(payload))
     _write_configuration(path, configuration)
     return configuration
 
@@ -261,17 +263,17 @@ def _read_legacy_workspace_id(
         connection.close()
 
 
-def _parse_v3_configuration(payload: Mapping[str, object]) -> NodeConfiguration:
+def _parse_v4_configuration(payload: Mapping[str, object]) -> NodeConfiguration:
     node = _table(payload.get("node", {}), "[node]")
     if "channel" in node or "runtime" in node:
         raise ConfigurationError(
-            "version 3 configuration cannot define node.channel or node.runtime"
+            "version 4 configuration cannot define node.channel or node.runtime"
         )
     raw_agents = payload.get("agent", [])
     if not isinstance(raw_agents, list):
         raise ConfigurationError("[[agent]] must be an array of TOML tables")
     agents = tuple(
-        _parse_v3_agent(item, index=index)
+        _parse_v4_agent(item, index=index)
         for index, item in enumerate(raw_agents, start=1)
     )
     version_check = node.get("version_check", True)
@@ -289,10 +291,26 @@ def _parse_v3_configuration(payload: Mapping[str, object]) -> NodeConfiguration:
     )
 
 
-def _parse_v3_agent(value: object, *, index: int) -> AgentConfiguration:
+def _parse_v4_agent(value: object, *, index: int) -> AgentConfiguration:
     table = _table(value, f"agent #{index}")
-    channel = _table(table.get("channel"), f"agent #{index}.channel")
-    channel_kind = _required_text(channel.get("kind"), f"agent #{index}.channel.kind")
+    raw_channels = table.get("channel")
+    if not isinstance(raw_channels, list):
+        raise ConfigurationError(
+            f"agent #{index}.channel must be an array of TOML tables"
+        )
+    channels: list[ChannelConfiguration] = []
+    for position, item in enumerate(raw_channels, start=1):
+        channel = _table(item, f"agent #{index}.channel #{position}")
+        channels.append(
+            ChannelConfiguration(
+                kind=_required_text(
+                    channel.get("kind"), f"agent #{index}.channel #{position}.kind"
+                ),
+                options=MappingProxyType(
+                    {key: option for key, option in channel.items() if key != "kind"}
+                ),
+            )
+        )
     raw_runtimes = table.get("runtime")
     if not isinstance(raw_runtimes, list):
         raise ConfigurationError(
@@ -333,12 +351,7 @@ def _parse_v3_agent(value: object, *, index: int) -> AgentConfiguration:
     return AgentConfiguration(
         id=_required_text(table.get("id"), f"agent #{index}.id"),
         name=_required_text(table.get("name"), f"agent #{index}.name"),
-        channel=ChannelConfiguration(
-            kind=channel_kind,
-            options=MappingProxyType(
-                {key: item for key, item in channel.items() if key != "kind"}
-            ),
-        ),
+        channels=tuple(channels),
         runtimes=tuple(runtimes),
         mode=mode,
         idle_timeout_seconds=float(idle_timeout),
@@ -533,10 +546,28 @@ def _v2_to_v3_payload(payload: Mapping[str, object]) -> dict[str, object]:
     return dict(payload) | {"version": "3", "agent": agents}
 
 
+def _v3_to_v4_payload(payload: Mapping[str, object]) -> dict[str, object]:
+    raw_agents = payload.get("agent", [])
+    if not isinstance(raw_agents, list):
+        raise ConfigurationError("[[agent]] must be an array of TOML tables")
+
+    agents: list[dict[str, object]] = []
+    for index, item in enumerate(raw_agents, start=1):
+        agent = dict(_table(item, f"agent #{index}"))
+        agent["channel"] = [_table(agent.get("channel"), f"agent #{index}.channel")]
+        agents.append(agent)
+
+    return dict(payload) | {"version": "4", "agent": agents}
+
+
 # The upgrade states, newest first so each one can name the state it moves to.
 # Adding a version means writing its upgrade, declaring it as the new terminal
 # state, and giving the state that used to be terminal an upgrade into it.
-_CONFIGURATION_V3 = _ConfigurationState(version="3", upgrade=None)
+_CONFIGURATION_V4 = _ConfigurationState(version="4", upgrade=None)
+_CONFIGURATION_V3 = _ConfigurationState(
+    version="3",
+    upgrade=_ConfigurationUpgrade(apply=_v3_to_v4_payload, state=_CONFIGURATION_V4),
+)
 _CONFIGURATION_V2 = _ConfigurationState(
     version="2",
     upgrade=_ConfigurationUpgrade(apply=_v2_to_v3_payload, state=_CONFIGURATION_V3),
@@ -549,6 +580,7 @@ _CONFIGURATION_STATES = (
     _CONFIGURATION_V1,
     _CONFIGURATION_V2,
     _CONFIGURATION_V3,
+    _CONFIGURATION_V4,
 )
 
 
@@ -614,15 +646,18 @@ def _serialize_configuration(configuration: NodeConfiguration) -> str:
                 f"name = {_toml_value(agent.name)}",
                 f"mode = {_toml_value(agent.mode.value)}",
                 f"idle_timeout = {_toml_value(agent.idle_timeout_seconds)}",
-                "",
-                "[agent.channel]",
-                f"kind = {_toml_value(agent.channel.kind)}",
             )
         )
-        for key in sorted(agent.channel.options):
-            lines.append(
-                f"{_toml_key(key)} = {_toml_value(agent.channel.options[key])}"
+        for channel in agent.channels:
+            lines.extend(
+                (
+                    "",
+                    "[[agent.channel]]",
+                    f"kind = {_toml_value(channel.kind)}",
+                )
             )
+            for key in sorted(channel.options):
+                lines.append(f"{_toml_key(key)} = {_toml_value(channel.options[key])}")
         for runtime in agent.runtimes:
             lines.extend(
                 (

{bazaar_compute_node-0.2.0rc5 → bazaar_compute_node-0.2.1rc2}/src/bazaar_compute_node/app/registry.py

@@ -29,7 +29,7 @@ class SharedAdapterFactories:
 
 @dataclass(frozen=True, slots=True)
 class AgentAdapterFactories:
-    channel: IChannelBuilder
+    channels: Mapping[str, IChannelBuilder]
     runtimes: Mapping[str, RuntimeFactory]
 
 
@@ -61,11 +61,14 @@ class AdapterRegistry:
     def load_agent(
         self,
         *,
-        channel: str,
+        channels: Sequence[str],
         runtimes: Sequence[str],
     ) -> AgentAdapterFactories:
         return AgentAdapterFactories(
-            channel=self._load_channel_builder(channel),
+            channels={
+                kind: self._load_channel_builder(kind)
+                for kind in dict.fromkeys(channels)
+            },
             runtimes={
                 kind: cast(
                     RuntimeFactory,