agentkernel 0.7.0__tar.gz → 0.8.0__tar.gz

{agentkernel-0.7.0 → agentkernel-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentkernel
-Version: 0.7.0
+Version: 0.8.0
 Summary: Agent Kernel - Unified AI Agents Runtime
 Author: Yaala Labs
 Author-email: Yaala Labs <agentkernel@yaalalabs.com>
@@ -26,6 +26,8 @@ Requires-Dist: chromadb>=0.4.0 ; extra == 'chromadb'
 Requires-Dist: crewai>=1.15.0 ; extra == 'crewai'
 Requires-Dist: openinference-instrumentation-crewai>=0.1.16 ; extra == 'crewai'
 Requires-Dist: openinference-instrumentation-litellm>=0.1.28 ; extra == 'crewai'
+Requires-Dist: daytona>=0.198.0,<0.199 ; extra == 'daytona'
+Requires-Dist: e2b-code-interpreter>=2.8.0 ; extra == 'e2b'
 Requires-Dist: google-cloud-firestore>=2.19.0 ; extra == 'gcp'
 Requires-Dist: google-auth>=2.0.0 ; extra == 'gmail'
 Requires-Dist: google-auth-oauthlib>=1.0.0 ; extra == 'gmail'
@@ -86,6 +88,8 @@ Provides-Extra: azure
 Provides-Extra: chromadb
 Provides-Extra: cli
 Provides-Extra: crewai
+Provides-Extra: daytona
+Provides-Extra: e2b
 Provides-Extra: gcp
 Provides-Extra: gmail
 Provides-Extra: instagram
@@ -126,7 +130,7 @@ Agent Kernel is a lightweight **AI agent runtime** and adapter layer for buildin
 - **Multi-Framework Support**: OpenAI Agents SDK, CrewAI, LangGraph, Google ADK, Smolagents, and Pydantic AI
 - **Session Management**: Built-in session abstraction with pluggable storage backends
 - **Knowledge Bases**: Unified `KnowledgeBase` interface with ChromaDB, Neo4j, and Starburst/Trino backends via `KnowledgeBuilder`
-- **Sandbox**: Execute agent-generated code and shell commands in an isolated, permission-bounded environment with pluggable providers (`local_subprocess`, `docker`), workload profiles, policy enforcement, and per-user identity
+- **Sandbox**: Execute agent-generated code and shell commands in an isolated, permission-bounded environment with pluggable providers (`local_subprocess`, `docker`, `e2b`, `daytona`, `ec2_ssm`), workload profiles, policy enforcement, and per-user identity
 - **Flexible Deployment**: Interactive CLI, REST API, serverless, or containerized deployment — see the "Multi-Cloud Deployment" section below
 - **Pluggable Architecture**: Easy to extend with custom framework adapters
 - **MCP Server**: Built-in Model Context Protocol server for exposing agents as MCP tools and exposing any custom tool
@@ -154,10 +158,14 @@ For LLM-based thread naming with Conversation Thread Support:
 pip install "agentkernel[thread]"
 ```
 
-For the Docker sandbox provider (the `local_subprocess` provider needs no extra):
+For the sandbox providers (the `local_subprocess` provider needs no extra; `ec2_ssm` rides
+the `aws` extra):
 
 ```bash
-pip install "agentkernel[sandbox-docker]"
+pip install "agentkernel[sandbox-docker]"   # docker provider
+pip install "agentkernel[e2b]"              # e2b cloud provider
+pip install "agentkernel[daytona]"          # daytona cloud provider
+pip install "agentkernel[aws]"              # ec2_ssm provider (boto3)
 ```
 
 **Requirements:**
@@ -1124,9 +1132,15 @@ Key fields:
 - **`enabled`** (`AK_SANDBOX__ENABLED`, default `false`) — master switch; inert when off.
 - **`agents`** — agent names the tools/prompt attach to; omit for all agents.
 - **`type`** (per profile) — `local_subprocess` (no isolation; dev/test), `docker`
-  (container isolation; `sandbox-docker` extra), or a dotted path to your own `SandboxProvider`.
+  (container isolation; `sandbox-docker` extra), `e2b` (managed micro-VMs; `e2b` extra),
+  `daytona` (cloud containers; `daytona` extra), `ec2_ssm` (attach to an existing EC2
+  instance via SSM; `aws` extra), or a dotted path to your own `SandboxProvider`.
 - **`scope`** — `per_call` (fresh per execution), `per_session` (persists across turns),
   `per_runtime` (one shared sandbox per profile).
+- **`environment`** — `managed` (default; the provider creates and disposes sandboxes) or
+  `attached` (deliberately connect to an existing environment the framework never owns,
+  e.g. an EC2 instance via `ec2_ssm`; requires the provider's `attach_to` and is validated
+  against the provider's lifecycle capabilities at startup).
 - **`policy`** — network egress, filesystem paths, cpu/memory, timeout; enforced per provider,
   fail-closed under `strict`.
 - **`identity.mode`** + **`principal_resolver`** — run code under the agent's or the invoking

{agentkernel-0.7.0 → agentkernel-0.8.0}/README.md

@@ -11,7 +11,7 @@ Agent Kernel is a lightweight **AI agent runtime** and adapter layer for buildin
 - **Multi-Framework Support**: OpenAI Agents SDK, CrewAI, LangGraph, Google ADK, Smolagents, and Pydantic AI
 - **Session Management**: Built-in session abstraction with pluggable storage backends
 - **Knowledge Bases**: Unified `KnowledgeBase` interface with ChromaDB, Neo4j, and Starburst/Trino backends via `KnowledgeBuilder`
-- **Sandbox**: Execute agent-generated code and shell commands in an isolated, permission-bounded environment with pluggable providers (`local_subprocess`, `docker`), workload profiles, policy enforcement, and per-user identity
+- **Sandbox**: Execute agent-generated code and shell commands in an isolated, permission-bounded environment with pluggable providers (`local_subprocess`, `docker`, `e2b`, `daytona`, `ec2_ssm`), workload profiles, policy enforcement, and per-user identity
 - **Flexible Deployment**: Interactive CLI, REST API, serverless, or containerized deployment — see the "Multi-Cloud Deployment" section below
 - **Pluggable Architecture**: Easy to extend with custom framework adapters
 - **MCP Server**: Built-in Model Context Protocol server for exposing agents as MCP tools and exposing any custom tool
@@ -39,10 +39,14 @@ For LLM-based thread naming with Conversation Thread Support:
 pip install "agentkernel[thread]"
 ```
 
-For the Docker sandbox provider (the `local_subprocess` provider needs no extra):
+For the sandbox providers (the `local_subprocess` provider needs no extra; `ec2_ssm` rides
+the `aws` extra):
 
 ```bash
-pip install "agentkernel[sandbox-docker]"
+pip install "agentkernel[sandbox-docker]"   # docker provider
+pip install "agentkernel[e2b]"              # e2b cloud provider
+pip install "agentkernel[daytona]"          # daytona cloud provider
+pip install "agentkernel[aws]"              # ec2_ssm provider (boto3)
 ```
 
 **Requirements:**
@@ -1009,9 +1013,15 @@ Key fields:
 - **`enabled`** (`AK_SANDBOX__ENABLED`, default `false`) — master switch; inert when off.
 - **`agents`** — agent names the tools/prompt attach to; omit for all agents.
 - **`type`** (per profile) — `local_subprocess` (no isolation; dev/test), `docker`
-  (container isolation; `sandbox-docker` extra), or a dotted path to your own `SandboxProvider`.
+  (container isolation; `sandbox-docker` extra), `e2b` (managed micro-VMs; `e2b` extra),
+  `daytona` (cloud containers; `daytona` extra), `ec2_ssm` (attach to an existing EC2
+  instance via SSM; `aws` extra), or a dotted path to your own `SandboxProvider`.
 - **`scope`** — `per_call` (fresh per execution), `per_session` (persists across turns),
   `per_runtime` (one shared sandbox per profile).
+- **`environment`** — `managed` (default; the provider creates and disposes sandboxes) or
+  `attached` (deliberately connect to an existing environment the framework never owns,
+  e.g. an EC2 instance via `ec2_ssm`; requires the provider's `attach_to` and is validated
+  against the provider's lifecycle capabilities at startup).
 - **`policy`** — network egress, filesystem paths, cpu/memory, timeout; enforced per provider,
   fail-closed under `strict`.
 - **`identity.mode`** + **`principal_resolver`** — run code under the agent's or the invoking

{agentkernel-0.7.0 → agentkernel-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "agentkernel"
-version = "0.7.0"
+version = "0.8.0"
 description = "Agent Kernel - Unified AI Agents Runtime"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -162,8 +162,14 @@ multimodal = [
 sandbox-docker = [
     "docker>=7.0.0",
 ]
-# The e2b, daytona, and kubernetes sandbox extras land with their providers in post-merge
-# iterations 9-10 (version floors confirmed against current SDKs at that point).
+e2b = [
+    "e2b-code-interpreter>=2.8.0",
+]
+daytona = [
+    # <0.199: from 0.199 the daytona api clients require pydantic>=2.13.4, which conflicts
+    # with crewai's pydantic<2.13 pin; 0.198 accepts pydantic>=2.11 and has the same SDK surface.
+    "daytona>=0.198.0,<0.199",
+]
 
 [project.scripts]
 ak = "agentkernel.cli.ak:main"

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/core/config.py

@@ -427,6 +427,22 @@ class _SandboxE2BConfig(BaseModel):
 class _SandboxDaytonaConfig(BaseModel):
     api_key_env: str = Field(default="DAYTONA_API_KEY", description="Name of the environment variable holding the Daytona API key")
     target: Optional[str] = Field(default=None, description="Daytona target/region; None uses the SDK default")
+    image: Optional[str] = Field(
+        default=None,
+        description="Container image for the sandbox (e.g. 'python:3.12-slim' or a registry image). Mutually exclusive with 'snapshot'; when neither is set Daytona uses its default snapshot.",
+    )
+    snapshot: Optional[str] = Field(
+        default=None,
+        description="Named Daytona snapshot to launch from. Mutually exclusive with 'image'; when neither is set Daytona uses its default snapshot.",
+    )
+    env_vars: dict[str, str] = Field(default_factory=dict, description="Environment variables set inside the sandbox")
+
+    @model_validator(mode="after")
+    def _image_snapshot_exclusive(self) -> "_SandboxDaytonaConfig":
+        """A sandbox launches from exactly one base — reject configuring both."""
+        if self.image and self.snapshot:
+            raise ValueError("daytona config sets both 'image' and 'snapshot'; they are mutually exclusive — pick one")
+        return self
 
 
 class _SandboxBedrockAgentCoreConfig(BaseModel):
@@ -446,10 +462,10 @@ class _SandboxEC2SSMConfig(BaseModel):
     attach_to: Optional[str] = Field(default=None, description="EC2 instance id to run commands against via SSM (attach-only)")
 
 
-class _SandboxBrokerConfig(BaseModel):
+class _ExecutionBrokerConfig(BaseModel):
     flavor: str = Field(
         default="thread",
-        description="Broker flavor: 'embedded' | 'thread' (in-process, available now) | a dotted path to a SandboxBroker subclass. The AWS 'sqs' flavor is planned in a later iteration.",
+        description="Broker flavor: 'embedded' | 'thread' (in-process, available now) | a dotted path to an ExecutionBroker subclass. The AWS 'sqs' flavor is planned in a later iteration.",
     )
     wait_timeout: float = Field(default=60.0, description="Max seconds a synchronous wait blocks before promotion to a task (0 = always promote)")
     inline_payload_max_bytes: int = Field(
@@ -478,6 +494,12 @@ class _SandboxProfileConfig(BaseModel):
         pattern="^(per_call|per_session|per_runtime)$",
         description="Sandbox lifetime: 'per_call' (new per execution), 'per_session' (per AK session), or 'per_runtime' (shared)",
     )
+    environment: str = Field(
+        default="managed",
+        pattern="^(managed|attached)$",
+        description="Environment lifecycle: 'managed' (the provider creates and disposes sandboxes) or 'attached' "
+        "(deliberately connect to an existing environment the framework never owns; requires the provider's attach_to)",
+    )
     idle_timeout: int = Field(default=1800, description="Seconds of inactivity before a sandbox session is closed on next touch")
     identity: _SandboxIdentityConfig = Field(default_factory=_SandboxIdentityConfig, description="Execution identity configuration")
     policy: _SandboxPolicyConfig = Field(
@@ -508,7 +530,7 @@ class _SandboxConfig(BaseModel):
         default=None, description="Dotted path to a PrincipalResolver mapping the session/agent to a SandboxPrincipal"
     )
     tool_output_max_chars: int = Field(default=8000, description="Maximum characters of tool output returned to the agent before truncation")
-    broker: _SandboxBrokerConfig = Field(default_factory=_SandboxBrokerConfig, description="Sandbox broker configuration")
+    broker: _ExecutionBrokerConfig = Field(default_factory=_ExecutionBrokerConfig, description="Sandbox broker configuration")
     profiles: dict[str, _SandboxProfileConfig] = Field(
         default_factory=dict, description="Named workload profiles, each selecting a provider and its policy/identity"
     )
@@ -522,6 +544,11 @@ class _SandboxConfig(BaseModel):
         pattern="^(per_call|per_session|per_runtime)$",
         description="Single-backend sugar: scope for the synthesized default profile",
     )
+    environment: Optional[str] = Field(
+        default=None,
+        pattern="^(managed|attached)$",
+        description="Single-backend sugar: environment lifecycle for the synthesized default profile",
+    )
     local_subprocess: Optional[_SandboxLocalSubprocessConfig] = Field(
         default=None, description="Single-backend sugar: 'local_subprocess' provider configuration"
     )
@@ -554,6 +581,8 @@ class _SandboxConfig(BaseModel):
             }
             if self.scope is not None:
                 profile_kwargs["scope"] = self.scope
+            if self.environment is not None:
+                profile_kwargs["environment"] = self.environment
             self.profiles = {self.default_profile: _SandboxProfileConfig(**profile_kwargs)}
         return self
 

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/deployment/azure/akfunction.py

@@ -41,6 +41,8 @@ class AzureFunctions:
 
             if isinstance(body, dict) and body.get("body") is not None:
                 body = BaseRunRequest.model_validate(body["body"])
+            elif isinstance(body, dict) and body:
+                body = BaseRunRequest.model_validate(body)
             else:
                 raise ValueError("Invalid request, request body cannot be empty or null")
 

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/__init__.py

@@ -11,9 +11,9 @@ providers, and broker flavors stay internal.
 """
 
 from . import errors
-from .base import Sandbox, SandboxProvider
-from .broker.base import SandboxBroker
-from .manager import SandboxManager
+from .base import AttachedEnvironment, AttachedEnvironmentProvider, Sandbox, SandboxProvider
+from .broker.base import ExecutionBroker
+from .manager import ExecutionManager
 from .model import (
     IsolationTier,
     SandboxCapabilities,
@@ -30,8 +30,10 @@ __all__ = [
     "errors",
     "Sandbox",
     "SandboxProvider",
-    "SandboxBroker",
-    "SandboxManager",
+    "AttachedEnvironmentProvider",
+    "AttachedEnvironment",
+    "ExecutionBroker",
+    "ExecutionManager",
     "PrincipalResolver",
     "AgentPrincipalResolver",
     "IsolationTier",

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/base.py

@@ -12,7 +12,7 @@ from typing import ClassVar
 
 from pydantic import BaseModel
 
-from .errors import SandboxCapabilityError
+from .errors import SandboxCapabilityError, SandboxConfigError
 from .model import SandboxCapabilities, SandboxPolicy, SandboxPrincipal, SandboxResult
 
 
@@ -20,7 +20,7 @@ class Sandbox(ABC):
     """Handle to one live sandbox. Created by a ``SandboxProvider``, never constructed directly.
 
     Concurrency: a ``Sandbox`` instance is used only from the event loop that created it,
-    with at most one in-flight execute call. Callers (``SandboxManager`` / broker worker)
+    with at most one in-flight execute call. Callers (``ExecutionManager`` / broker worker)
     uphold this via a per-``sandbox_session_id`` lock; providers may assume it.
     """
 
@@ -110,3 +110,45 @@ class SandboxProvider(ABC):
     @abstractmethod
     async def destroy(self, sandbox_id: str) -> None:
         """Permanently dispose backend state. Idempotent; unknown ids are a no-op."""
+
+
+class AttachedEnvironment(Sandbox):
+    """Handle to an environment the framework connects to but never owns.
+
+    The handle counterpart of ``AttachedEnvironmentProvider``: where a ``Sandbox`` handle
+    fronts something the provider created (and will eventually destroy), an ``AttachedEnvironment``
+    fronts something that already exists independently — an EC2 instance, a running pod, a
+    production service. Concrete attach-only handles subclass this instead of ``Sandbox``
+    so their names stop claiming sandbox-ness (e.g. ``EC2SSMEnvironment``).
+
+    The one lifecycle rule it fixes: ``close()`` is a no-op — releasing the handle must
+    never affect an environment that runs independently of the framework.
+    """
+
+    async def close(self) -> None:
+        """Nothing to release — the environment runs independently of the framework. Idempotent."""
+        return None
+
+
+class AttachedEnvironmentProvider(SandboxProvider):
+    """Base for attach-only providers: environments the framework connects to but never owns.
+
+    Subclasses bind to something that already exists (an EC2 instance, a running pod, a
+    production service) and therefore implement only ``attach``, returning an
+    ``AttachedEnvironment`` handle. This base fixes the lifecycle non-ownership once: ``create``
+    binds to the configured ``attach_to`` target (never provisions) and ``destroy`` is a
+    no-op (never disposes). Declare ``provisions=False`` and ``attaches_external=True`` in
+    ``capabilities``; profiles selecting such a provider must opt in with
+    ``environment: attached``.
+    """
+
+    async def create(self, *, principal: SandboxPrincipal, policy: SandboxPolicy) -> Sandbox:
+        """Bind to the configured ``attach_to`` target — attach-only providers never provision."""
+        attach_to = getattr(self._config, "attach_to", None)
+        if not attach_to:
+            raise SandboxConfigError(f"{self.__class__.__name__} is attach-only: configure the profile's attach_to with the target to connect to")
+        return await self.attach(attach_to, principal=principal, policy=policy)
+
+    async def destroy(self, sandbox_id: str) -> None:
+        """No-op — the provider never owns the environment, so there is nothing to dispose."""
+        return None

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/broker/__init__.py

@@ -1,8 +1,8 @@
 """Sandbox broker: decouples the agentic system from sandbox execution.
 
-The broker's message models and ``SandboxBroker`` ABC live in ``base``; the
+The broker's message models and ``ExecutionBroker`` ABC live in ``base``; the
 flavor-independent execution engine in ``worker`` (``BrokerWorkerCore``); and the
 individual flavors in their own modules (``embedded`` and ``thread`` here; the AWS
 ``sqs`` flavor lands in a later iteration). Flavors are resolved lazily by
-``SandboxBrokerFactory`` so importing this package pulls in no flavor by default.
+``ExecutionBrokerFactory`` so importing this package pulls in no flavor by default.
 """

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/broker/base.py

@@ -1,7 +1,7 @@
-"""Broker wire contract and the ``SandboxBroker`` ABC.
+"""Broker wire contract and the ``ExecutionBroker`` ABC.
 
-``SandboxBrokerRequest``/``SandboxCompletion`` are the public messages exchanged between
-the agent-side ``SandboxManager`` and a broker worker. They are self-sufficient — a request
+``ExecutionRequest``/``ExecutionCompletion`` are the public messages exchanged between
+the agent-side ``ExecutionManager`` and a broker worker. They are self-sufficient — a request
 carries the resolved principal, policy, and the sandbox session (including the reconnect
 handle) so a remote worker needs nothing else to execute it.
 """
@@ -18,30 +18,30 @@ BrokerOperation = Literal["execute_code", "execute_command", "install_packages",
 
 
 class BoundedCompletionStore:
-    """A bounded, LRU-evicting ``task_id -> SandboxCompletion`` map for the in-process broker
+    """A bounded, LRU-evicting ``task_id -> ExecutionCompletion`` map for the in-process broker
     flavors, so a long-running server does not accumulate one completion per execution for the
     process lifetime. The cap only bounds the tail: a completion is normally dropped as soon as
-    ``SandboxManager`` consumes it (``discard``), and promoted tasks are polled within seconds —
+    ``ExecutionManager`` consumes it (``discard``), and promoted tasks are polled within seconds —
     far inside the cap — while synchronous results are never polled at all and just age out."""
 
     def __init__(self, maxlen: int = 1024) -> None:
         self._maxlen = maxlen
-        self._items: "OrderedDict[str, SandboxCompletion]" = OrderedDict()
+        self._items: "OrderedDict[str, ExecutionCompletion]" = OrderedDict()
 
-    def set(self, task_id: str, completion: "SandboxCompletion") -> None:
+    def set(self, task_id: str, completion: "ExecutionCompletion") -> None:
         self._items[task_id] = completion
         self._items.move_to_end(task_id)
         while len(self._items) > self._maxlen:
             self._items.popitem(last=False)  # evict the oldest
 
-    def get(self, task_id: str) -> Optional["SandboxCompletion"]:
+    def get(self, task_id: str) -> Optional["ExecutionCompletion"]:
         return self._items.get(task_id)
 
     def discard(self, task_id: str) -> None:
         self._items.pop(task_id, None)
 
 
-class SandboxBrokerRequest(BaseModel):
+class ExecutionRequest(BaseModel):
     task_id: str
     operation: BrokerOperation
     payload: dict[str, Any] = Field(default_factory=dict)  # operation arguments
@@ -54,7 +54,7 @@ class SandboxBrokerRequest(BaseModel):
     wait_deadline: Optional[float] = None  # epoch seconds; None = caller will not wait
 
 
-class SandboxCompletion(BaseModel):
+class ExecutionCompletion(BaseModel):
     task_id: str
     status: Literal["succeeded", "failed", "timed_out"]
     result: Optional[SandboxResult] = None  # inline when small
@@ -63,7 +63,7 @@ class SandboxCompletion(BaseModel):
     sandbox_session: SandboxSession  # updated handle (e.g. newly created sandbox_id)
 
 
-class SandboxBroker(ABC):
+class ExecutionBroker(ABC):
     """Transport between the agent-side manager and the execution engine.
 
     In-process flavors (``embedded``, ``thread``) run ``BrokerWorkerCore`` locally; the AWS
@@ -71,12 +71,12 @@ class SandboxBroker(ABC):
     """
 
     @abstractmethod
-    async def submit(self, request: SandboxBrokerRequest, wait: Optional[float]) -> Union[SandboxResult, SandboxTask]:
+    async def submit(self, request: ExecutionRequest, wait: Optional[float]) -> Union[SandboxResult, SandboxTask]:
         """Submit a request. Returns a ``SandboxResult`` when it completes within ``wait``,
         or a ``SandboxTask`` handle when execution is promoted to run asynchronously."""
 
     @abstractmethod
-    async def result(self, task_id: str) -> Optional[SandboxCompletion]:
+    async def result(self, task_id: str) -> Optional[ExecutionCompletion]:
         """Return the completion for a previously submitted task, or None if not yet available."""
 
     async def discard(self, task_id: str) -> None:

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/broker/embedded.py

@@ -11,18 +11,18 @@ from typing import Optional, Union
 from pydantic import BaseModel
 
 from ..model import SandboxResult, SandboxTask
-from .base import BoundedCompletionStore, SandboxBroker, SandboxBrokerRequest, SandboxCompletion
+from .base import BoundedCompletionStore, ExecutionBroker, ExecutionCompletion, ExecutionRequest
 from .worker import BrokerWorkerCore
 
 
-class EmbeddedBroker(SandboxBroker):
+class EmbeddedBroker(ExecutionBroker):
     def __init__(self, config: Optional[BaseModel] = None) -> None:
         """Create the broker with its own in-process ``BrokerWorkerCore``; ``config`` (the
         ``sandbox.broker`` block) is accepted for factory uniformity but unused."""
         self._worker = BrokerWorkerCore()
         self._completions = BoundedCompletionStore()
 
-    async def submit(self, request: SandboxBrokerRequest, wait: Optional[float] = None) -> Union[SandboxResult, SandboxTask]:
+    async def submit(self, request: ExecutionRequest, wait: Optional[float] = None) -> Union[SandboxResult, SandboxTask]:
         """Run the request inline to completion and return its ``SandboxResult``.
 
         ``wait`` is ignored (always synchronous, never promotes). ``run()`` raises the real
@@ -30,10 +30,12 @@ class EmbeddedBroker(SandboxBroker):
         layer) sees the true exception type.
         """
         result, session = await self._worker.run(request)
-        self._completions.set(request.task_id, SandboxCompletion(task_id=request.task_id, status="succeeded", result=result, sandbox_session=session))
+        self._completions.set(
+            request.task_id, ExecutionCompletion(task_id=request.task_id, status="succeeded", result=result, sandbox_session=session)
+        )
         return result
 
-    async def result(self, task_id: str) -> Optional[SandboxCompletion]:
+    async def result(self, task_id: str) -> Optional[ExecutionCompletion]:
         """Return the completion recorded for ``task_id`` in this process, or ``None``."""
         return self._completions.get(task_id)
 

{agentkernel-0.7.0 → agentkernel-0.8.0}/src/agentkernel/sandbox/broker/thread.py

@@ -8,7 +8,7 @@ the response future back to the caller's loop:
   ``SandboxError``, matching the embedded flavor).
 * ``wait=N`` bounds the wait; on expiry the execution is promoted to a ``SandboxTask``
   and continues on the broker thread. Its completion is kept in worker memory and,
-  because the process is shared, ``result()`` serves it to ``SandboxManager.task_status``.
+  because the process is shared, ``result()`` serves it to ``ExecutionManager.task_status``.
 
 Concurrency contract: every provider handle is created and used only on the broker
 thread's loop — callers never touch one.
@@ -23,15 +23,15 @@ from typing import Optional, Union
 
 from pydantic import BaseModel
 
-from ..errors import SandboxBrokerError, SandboxTimeoutError
+from ..errors import ExecutionBrokerError, SandboxTimeoutError
 from ..model import SandboxResult, SandboxTask
-from .base import BoundedCompletionStore, SandboxBroker, SandboxBrokerRequest, SandboxCompletion
+from .base import BoundedCompletionStore, ExecutionBroker, ExecutionCompletion, ExecutionRequest
 from .worker import BrokerWorkerCore
 
 logger = logging.getLogger("ak.sandbox.broker")
 
 
-class ThreadBroker(SandboxBroker):
+class ThreadBroker(ExecutionBroker):
     """In-process broker running executions on a dedicated daemon thread."""
 
     def __init__(self, config: Optional[BaseModel] = None) -> None:
@@ -56,7 +56,7 @@ class ThreadBroker(SandboxBroker):
             if self._thread is not None:
                 return
             if self._closed:
-                raise SandboxBrokerError("sandbox thread broker is closed")
+                raise ExecutionBrokerError("sandbox thread broker is closed")
             self._thread = threading.Thread(target=self._run_loop, name="ak-sandbox-broker", daemon=True)
             self._thread.start()
         self._ready.wait()
@@ -100,7 +100,7 @@ class ThreadBroker(SandboxBroker):
 
     # -- request path -------------------------------------------------------- #
 
-    async def submit(self, request: SandboxBrokerRequest, wait: Optional[float] = None) -> Union[SandboxResult, SandboxTask]:
+    async def submit(self, request: ExecutionRequest, wait: Optional[float] = None) -> Union[SandboxResult, SandboxTask]:
         """Enqueue the request on the broker loop and await its result.
 
         ``wait=None`` awaits indefinitely; ``wait=N`` promotes to a ``SandboxTask`` on
@@ -127,7 +127,7 @@ class ThreadBroker(SandboxBroker):
                 submitted_at=time.time(),
             )
 
-    async def _handle(self, request: SandboxBrokerRequest, response: concurrent.futures.Future) -> None:
+    async def _handle(self, request: ExecutionRequest, response: concurrent.futures.Future) -> None:
         """Run one request on the broker loop; store its completion and deliver the result
         (or the real exception) to a caller that is still waiting."""
         try:
@@ -142,16 +142,16 @@ class ThreadBroker(SandboxBroker):
         else:
             self._completions.set(
                 request.task_id,
-                SandboxCompletion(task_id=request.task_id, status="succeeded", result=result, sandbox_session=session),
+                ExecutionCompletion(task_id=request.task_id, status="succeeded", result=result, sandbox_session=session),
             )
             if not response.done():
                 response.set_result(result)
 
-    def _complete(self, request: SandboxBrokerRequest, status: str, *, error: str) -> None:
+    def _complete(self, request: ExecutionRequest, status: str, *, error: str) -> None:
         """Record a terminal failure completion for ``result()`` lookups."""
         self._completions.set(
             request.task_id,
-            SandboxCompletion(task_id=request.task_id, status=status, error=error, sandbox_session=request.sandbox_session),
+            ExecutionCompletion(task_id=request.task_id, status=status, error=error, sandbox_session=request.sandbox_session),
         )
 
     @staticmethod
@@ -161,7 +161,7 @@ class ThreadBroker(SandboxBroker):
         if not response.done():
             response.set_exception(exc)
 
-    async def result(self, task_id: str) -> Optional[SandboxCompletion]:
+    async def result(self, task_id: str) -> Optional[ExecutionCompletion]:
         """Return the completion held in worker memory for ``task_id``, or ``None``."""
         return self._completions.get(task_id)