bazaar-compute-node 0.1.32__tar.gz → 0.1.34__tar.gz

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.32
+Version: 0.1.34
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -8,6 +8,7 @@ Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: cryptography>=45.0.0
 Requires-Dist: jinja2>=3.1.6
+Requires-Dist: packaging>=25.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: protobug==1.0.0
 Requires-Dist: tzdata>=2024.1 ; sys_platform == 'win32'

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.32"
+version = "0.1.34"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -11,6 +11,7 @@ dependencies = [
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
     "jinja2>=3.1.6",
+    "packaging>=25.0",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.34}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.32"
+version = "0.1.34"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -11,6 +11,7 @@ dependencies = [
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
     "jinja2>=3.1.6",
+    "packaging>=25.0",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

bazaar_compute_node-0.1.34/src/bazaar_compute_node/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+__distribution__ = "bazaar-compute-node"
+__version__ = version(__distribution__)

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.34}/src/bazaar_compute_node/app/agent.py

@@ -9,12 +9,17 @@ import re
 import secrets
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
+from functools import partial
 from pathlib import Path
 
 from ..core.channel import AgentScopedChannel, ChannelContext, IChannel
 from ..core.concurrency import ISessionConcurrency, SessionLockRegistry
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import InboundAttachment, Message, RuntimeSession
+from ..core.models import (
+    InboundAttachment,
+    Message,
+    RuntimeSession,
+)
 from ..core.observability import IAudit
 from ..core.orchestration import SessionOrchestrator
 from ..core.orchestration.reminder_command import ReminderCommandService
@@ -28,6 +33,7 @@ from .command import CommandDispatchError
 from .config import AgentConfiguration
 from .registry import AgentAdapterFactories
 from .resource_dispatch import CommandDispatcher
+from .upgrade import UpgradeService
 from .wrapper import install_bcc_wrapper, remove_bcc_wrapper
 
 CommandRecord = tuple[str, tuple[str, ...]]
@@ -73,6 +79,8 @@ class AgentApplication:
         endpoint: Callable[[], str],
         timeout_budget: TimeoutBudget,
         translator: Translator,
+        upgrade_service: UpgradeService,
+        upgrade_notice: Callable[[], tuple[str, str] | None] = lambda: None,
     ) -> None:
         self.configuration = configuration
         self.agent_id = configuration.id
@@ -89,7 +97,7 @@ class AgentApplication:
         self._concurrency = SessionLockRegistry()
         self._started = False
         self._stopping = False
-        self._runtime_environment_include = configuration.runtime.env_include
+        self._runtime_configurations = configuration.runtimes
         self._logger = logging.getLogger("bazaar_compute_node.application.agent")
         self._attachment_materializer = AttachmentMaterializer(
             self.workspace_path,
@@ -106,54 +114,64 @@ class AgentApplication:
             )
         )
         self.channel: IChannel = AgentScopedChannel(self.agent_id, provider_channel)
-        runtime_options: dict[str, str] = {
-            key: value
-            for key, value in configuration.runtime.options.items()
-            if isinstance(value, str)
-        }
-        if configuration.runtime.model is not None:
-            runtime_options["model"] = configuration.runtime.model
-        if configuration.runtime.effort is not None:
-            runtime_options["effort"] = configuration.runtime.effort
-        self._runtime_context = RuntimeCommandContext(
-            run_command=self._run_runtime_command,
-            environment_for_session=self._runtime_environment,
-            agent_id=self.agent_id,
-            agent_name=self.name,
-            bot_name=self._bot_name,
-            runtime_options=runtime_options,
-            sandbox_mode=configuration.runtime.sandbox_mode,
-            network_access=configuration.runtime.network_access,
-            startup_timeout_seconds=timeout_budget.startup_seconds,
-        )
-        self.runtime: IRuntime = factories.runtime(self._runtime_context)
-        idle_timeout_seconds = configuration.runtime.idle_timeout_seconds
+        runtime_contexts: list[RuntimeCommandContext] = []
+        runtimes: list[IRuntime] = []
+        for index, runtime_configuration in enumerate(configuration.runtimes):
+            runtime_options: dict[str, str] = {
+                key: value
+                for key, value in runtime_configuration.options.items()
+                if isinstance(value, str)
+            }
+            if runtime_configuration.model is not None:
+                runtime_options["model"] = runtime_configuration.model
+            if runtime_configuration.effort is not None:
+                runtime_options["effort"] = runtime_configuration.effort
+            context = RuntimeCommandContext(
+                run_command=self._run_runtime_command,
+                # the context belongs to one instance, so the index it builds
+                # the child environment for is fixed here
+                environment_for_session=partial(self._runtime_environment, index),
+                agent_id=self.agent_id,
+                agent_name=self.name,
+                bot_name=self._bot_name,
+                runtime_options=runtime_options,
+                sandbox_mode=runtime_configuration.sandbox_mode,
+                network_access=runtime_configuration.network_access,
+                startup_timeout_seconds=timeout_budget.startup_seconds,
+            )
+            runtime_contexts.append(context)
+            runtimes.append(factories.runtimes[runtime_configuration.kind](context))
+        idle_timeout_seconds = configuration.idle_timeout_seconds
         if (
             isinstance(idle_timeout_seconds, bool)
             or not isinstance(idle_timeout_seconds, int | float)
             or not math.isfinite(idle_timeout_seconds)
         ):
-            raise ValueError("runtime idle timeout must be a finite number")
+            raise ValueError("agent idle timeout must be a finite number")
         if (
             idle_timeout_seconds > 0
             and idle_timeout_seconds * 1_000 > timer_wheel.maximum_delay_ms
         ):
-            raise ValueError("runtime idle timeout exceeds the timer horizon")
-        runtime_idle_timeout_ms = (
-            math.ceil(idle_timeout_seconds * 1_000) if idle_timeout_seconds > 0 else 0
-        )
+            raise ValueError("agent idle timeout exceeds the timer horizon")
+        self._runtime_contexts = tuple(runtime_contexts)
+        self.runtimes: tuple[IRuntime, ...] = tuple(runtimes)
         self.orchestrator = SessionOrchestrator(
             agent_id=self.agent_id,
             channel=self.channel,
-            runtime=self.runtime,
+            runtimes=self.runtimes,
             storage=self.storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
-            runtime_idle_timeout_ms=runtime_idle_timeout_ms,
+            runtime_idle_timeout_ms=(
+                math.ceil(idle_timeout_seconds * 1_000)
+                if idle_timeout_seconds > 0
+                else 0
+            ),
             workspace=self.workspace_path,
             translator=self.translator,
             error_feedback_detail=self._error_feedback_detail,
+            upgrade_notice=upgrade_notice,
             concurrency=self._concurrency,
         )
         self.reminder_service = ReminderCommandService(
@@ -161,21 +179,12 @@ class AgentApplication:
             concurrency=reminder_concurrency,
             poke=reminder_poke,
         )
-        self._provider_control_handler = (
-            factories.control(self._adapter_context())
-            if factories.control is not None
-            else None
-        )
         self.command_dispatcher = CommandDispatcher(
             self.orchestrator.command_service,
             reminder_service=self.reminder_service,
             timeout_budget=self.timeout_budget,
-            control_handler=(
-                self._handle_control
-                if self._provider_control_handler is not None
-                else None
-            ),
             session_binding_validator=self._validate_session_binding,
+            upgrade_service=upgrade_service,
         )
 
     @property
@@ -275,7 +284,7 @@ class AgentApplication:
             "name": self.name,
             "status": "started" if self.started else "stopped",
             "channel": self.channel.name,
-            "runtime": self.runtime.name,
+            "runtimes": tuple(runtime.name for runtime in self.runtimes),
             "channel_health": dict(self.channel.health),
             "orchestrator_health": self.orchestrator.health,
         }
@@ -303,37 +312,6 @@ class AgentApplication:
     async def _referenced_attachment_paths(self) -> set[str]:
         return set(await self.storage.list_ready_attachment_paths())
 
-    def _adapter_context(self) -> Mapping[str, object]:
-        return {
-            "agent_id": self.agent_id,
-            "agent_name": self.name,
-            "channel": self.channel,
-            "runtime": self.runtime,
-            "storage": self.storage,
-            "audit": self.audit,
-            "command_log": self.command_log,
-            "is_started": lambda: self._started,
-        }
-
-    async def _handle_control(
-        self,
-        request: Mapping[str, object],
-    ) -> Mapping[str, object]:
-        session_id = request.get("session_id")
-        if not isinstance(session_id, str) or not session_id:
-            raise CommandDispatchError(
-                "SESSION_REQUIRED",
-                "session_id must be a non-empty string",
-            )
-        await self._validate_session_binding(session_id, request)
-        handler = self._provider_control_handler
-        if handler is None:
-            raise CommandDispatchError(
-                "INVALID_COMMAND",
-                "control operation is not supported",
-            )
-        return await handler(request)
-
     async def _validate_session_binding(
         self,
         session_id: str,
@@ -374,19 +352,26 @@ class AgentApplication:
                 "session capability is invalid",
             )
 
-    def _runtime_environment(self, session: RuntimeSession) -> Mapping[str, str]:
+    def _runtime_environment(
+        self,
+        runtime_index: int,
+        session: RuntimeSession,
+    ) -> Mapping[str, str]:
         runtime_session = self.orchestrator.runtime_session(session.bcn_session_id)
         if runtime_session is None or runtime_session.id != session.id:
             raise RuntimeError("runtime session is not the current live binding")
         return self._build_command_environment(
             session.bcn_session_id,
             session.id,
+            runtime_index=runtime_index,
         )
 
     def _build_command_environment(
         self,
         session_id: str,
         runtime_session_id: str,
+        *,
+        runtime_index: int,
     ) -> dict[str, str]:
         if not session_id:
             raise ValueError("session_id must be a non-empty string")
@@ -395,14 +380,15 @@ class AgentApplication:
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
+        environment_bindings = self._runtime_configurations[runtime_index].env
         binding = self._session_capabilities.get(session_id)
         if binding is None or binding.runtime_session_id != runtime_session_id:
             capability = secrets.token_urlsafe(32)
             token_values = [capability]
-            for name in self._runtime_environment_include:
+            for name, source_name in environment_bindings.items():
                 if name != "TOKEN" and not name.endswith("_TOKEN"):
                     continue
-                value = os.environ.get(name)
+                value = os.environ.get(source_name)
                 if value and value not in token_values:
                     token_values.append(value)
             binding = _SessionCapabilityBinding(
@@ -414,19 +400,32 @@ class AgentApplication:
             )
             self._session_capabilities[session_id] = binding
         allowed = set(_PLATFORM_ENVIRONMENT)
-        for name in self.runtime.environment_variable_names():
-            if not _ENVIRONMENT_NAME.fullmatch(name):
-                raise ValueError(f"runtime environment name is invalid: {name}")
-            allowed.add(name)
-        for name in self._runtime_environment_include:
+        for name in self.runtimes[runtime_index].environment_variable_names():
             if not _ENVIRONMENT_NAME.fullmatch(name):
                 raise ValueError(f"runtime environment name is invalid: {name}")
-            if name not in os.environ:
-                raise ValueError(f"runtime environment variable is missing: {name}")
             allowed.add(name)
         environment = {
             name: os.environ[name] for name in sorted(allowed) if os.environ.get(name)
         }
+        bound: dict[str, str] = {}
+        for name, source_name in sorted(environment_bindings.items()):
+            for candidate in (name, source_name):
+                if not _ENVIRONMENT_NAME.fullmatch(candidate):
+                    raise ValueError(
+                        f"runtime environment name is invalid: {candidate}"
+                    )
+            if source_name not in os.environ:
+                raise ValueError(
+                    f"runtime environment variable is missing: {source_name}"
+                )
+            bound[name] = os.environ[source_name]
+        for source_name in environment_bindings.values():
+            # the credential reaches the child only under the name it asked for,
+            # never under the node's own name for it, unless the child asked for
+            # that name as well
+            if source_name not in environment_bindings:
+                environment.pop(source_name, None)
+        environment.update(bound)
         environment["PATH"] = os.pathsep.join(
             (str(wrapper_path.parent), environment.get("PATH", os.defpath))
         )
@@ -479,6 +478,7 @@ class AgentApplication:
         environment = self._build_command_environment(
             session_id,
             runtime_session.id,
+            runtime_index=runtime_session.runtime_index,
         )
         process = await asyncio.create_subprocess_exec(
             str(wrapper_path),

{bazaar_compute_node-0.1.32 → bazaar_compute_node-0.1.34}/src/bazaar_compute_node/app/agent_management.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import sys
 import tomllib
 from dataclasses import replace
 from types import MappingProxyType
@@ -84,25 +85,38 @@ def run_agent_command(
         for agent in configuration.agents:
             print(
                 f"id={agent.id} name={agent.name} "
-                f"channel={agent.channel.kind} runtime={agent.runtime.kind}",
+                f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
                 flush=True,
             )
         return 0
 
     if command == "add":
+        agent_values: dict[str, object] = {}
         channel_options: dict[str, object] = {}
         runtime_values: dict[str, object] = {}
+        runtime_env: dict[str, str] = {}
         seen: set[tuple[str, str]] = set()
         for scope, key, value in args.agent_options:
+            # runtime.env accumulates one name per --set; a repeated name is
+            # simply overwritten, the same as a hand-edited config.toml would be
+            if (scope, key) == ("runtime", "env"):
+                runtime_env.update(value)
+                continue
             identity = (scope, key)
             if identity in seen:
                 parser.error(f"duplicate --set option: {scope}.{key}")
             seen.add(identity)
-            if scope == "channel":
+            if scope == "agent":
+                agent_values[key] = value
+            elif scope == "channel":
                 channel_options[key] = value
             else:
                 runtime_values[key] = value
 
+        idle_timeout = agent_values.pop("idle_timeout", 0)
+        if isinstance(idle_timeout, bool) or not isinstance(idle_timeout, int | float):
+            parser.error("agent.idle_timeout must be a number")
+
         model = runtime_values.pop("model", None)
         effort = runtime_values.pop("effort", None)
         raw_sandbox_mode = runtime_values.pop(
@@ -119,16 +133,6 @@ def run_agent_command(
         network_access = runtime_values.pop("network_access", True)
         if not isinstance(network_access, bool):
             parser.error("runtime.network_access must be a boolean")
-        idle_timeout = runtime_values.pop("idle_timeout", 0)
-        if isinstance(idle_timeout, bool) or not isinstance(idle_timeout, int | float):
-            parser.error("runtime.idle_timeout must be a number")
-        raw_env_include = runtime_values.pop("env_include", [])
-        if not isinstance(raw_env_include, list) or any(
-            not isinstance(item, str) or not item for item in raw_env_include
-        ):
-            parser.error("runtime.env_include must be an array of non-empty text")
-        if len(set(raw_env_include)) != len(raw_env_include):
-            parser.error("runtime.env_include cannot contain duplicates")
         if model is not None and not isinstance(model, str):
             parser.error("runtime.model must be text")
         if effort is not None and not isinstance(effort, str):
@@ -142,16 +146,18 @@ def run_agent_command(
                     kind=args.channel,
                     options=MappingProxyType(channel_options),
                 ),
-                runtime=RuntimeConfiguration(
-                    kind=args.runtime,
-                    model=model,
-                    effort=effort,
-                    sandbox_mode=sandbox_mode,
-                    network_access=network_access,
-                    idle_timeout_seconds=idle_timeout,
-                    env_include=tuple(raw_env_include),
-                    options=MappingProxyType(runtime_values),
+                runtimes=(
+                    RuntimeConfiguration(
+                        kind=args.runtime,
+                        model=model,
+                        effort=effort,
+                        sandbox_mode=sandbox_mode,
+                        network_access=network_access,
+                        env=MappingProxyType(runtime_env),
+                        options=MappingProxyType(runtime_values),
+                    ),
                 ),
+                idle_timeout_seconds=idle_timeout,
             )
             updated = replace(
                 configuration,
@@ -162,7 +168,7 @@ def run_agent_command(
             parser.error(str(error))
         print(
             f"Agent added id={agent.id} name={agent.name} "
-            f"channel={agent.channel.kind} runtime={agent.runtime.kind}",
+            f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
             flush=True,
         )
         print("Run `bcn restart` to apply.", flush=True)
@@ -204,23 +210,60 @@ def _agent_option(value: str) -> tuple[str, str, object]:
     if path != path.strip():
         raise argparse.ArgumentTypeError("--set option path cannot contain whitespace")
     scope, dot, key = path.partition(".")
-    if not dot or scope not in {"channel", "runtime"} or not key:
+    if not dot or scope not in {"agent", "channel", "runtime"} or not key:
         raise argparse.ArgumentTypeError(
-            "--set path must start with channel. or runtime."
+            "--set path must start with agent., channel. or runtime."
         )
     if key != key.strip():
         raise argparse.ArgumentTypeError(
             "--set option key cannot contain edge whitespace"
         )
-    if key == "kind":
+    if key == "kind" and scope != "agent":
         raise argparse.ArgumentTypeError(
             f"{scope}.kind must be provided with --{scope}"
         )
+    if scope == "runtime" and key == "env":
+        return scope, key, _env_pair(raw_value)
     try:
         parsed = tomllib.loads(f"value = {raw_value}")["value"]
     except tomllib.TOMLDecodeError:
         parsed = raw_value
+    if scope == "runtime" and key == "env_include":
+        return scope, "env", _env_from_deprecated_include(parsed)
     return scope, key, parsed
 
 
+def _env_pair(value: str) -> dict[str, str]:
+    name, separator, source = value.partition("=")
+    if not separator or not name or not source:
+        raise argparse.ArgumentTypeError(
+            "runtime.env must use <name>=<source>, for example "
+            "--set runtime.env=CODEX_HOME=BCN_CODEX_HOME_WORK"
+        )
+    return {name: source}
+
+
+def _env_from_deprecated_include(value: object) -> dict[str, str]:
+    if not isinstance(value, list) or any(
+        not isinstance(item, str) or not item for item in value
+    ):
+        raise argparse.ArgumentTypeError(
+            "runtime.env_include must be an array of non-empty text"
+        )
+    if len(set(value)) != len(value):
+        raise argparse.ArgumentTypeError(
+            "runtime.env_include cannot contain duplicates"
+        )
+    print(
+        create_translator(None).text("cli.agent.env_include_deprecated"),
+        file=sys.stderr,
+        flush=True,
+    )
+    return {name: name for name in value}
+
+
+def _runtime_kinds(agent: AgentConfiguration) -> str:
+    return ",".join(runtime.kind for runtime in agent.runtimes)
+
+
 __all__ = ["build_agent_parser", "run_agent_command"]