flowent 0.3.2__tar.gz → 0.3.4__tar.gz

{flowent-0.3.2 → flowent-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowent
-Version: 0.3.2
+Version: 0.3.4
 Summary: A workflow orchestration platform for multi-agent collaboration
 Keywords: agent,agents,ai,ai-agents,assistant,automation,code-generation,llm,mcp,orchestration,sandbox,web-application,workflow
 Author: ImFeH2
@@ -31,7 +31,10 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/v/flowent.svg?style=flat-square&label=npm" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/dm/flowent.svg?style=flat-square&label=npm" alt="npm monthly downloads" /></a>
   <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/v/flowent.svg?style=flat-square&label=PyPI" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/dm/flowent.svg?style=flat-square&label=PyPI" alt="PyPI monthly downloads" /></a>
+  <br />
   <a href="https://github.com/ImFeH2/flowent/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/flowent.svg?style=flat-square&label=License" alt="License" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/ci.yml"><img src="https://github.com/ImFeH2/flowent/workflows/CI/badge.svg" alt="CI" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/release.yml"><img src="https://github.com/ImFeH2/flowent/workflows/Release/badge.svg" alt="Release" /></a>

{flowent-0.3.2 → flowent-0.3.4}/README.md

@@ -4,7 +4,10 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/v/flowent.svg?style=flat-square&label=npm" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/dm/flowent.svg?style=flat-square&label=npm" alt="npm monthly downloads" /></a>
   <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/v/flowent.svg?style=flat-square&label=PyPI" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/dm/flowent.svg?style=flat-square&label=PyPI" alt="PyPI monthly downloads" /></a>
+  <br />
   <a href="https://github.com/ImFeH2/flowent/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/flowent.svg?style=flat-square&label=License" alt="License" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/ci.yml"><img src="https://github.com/ImFeH2/flowent/workflows/CI/badge.svg" alt="CI" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/release.yml"><img src="https://github.com/ImFeH2/flowent/workflows/Release/badge.svg" alt="Release" /></a>

{flowent-0.3.2 → flowent-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.3.2"
+version = "0.3.4"
 description = "A workflow orchestration platform for multi-agent collaboration"
 readme = "README.md"
 authors = [

{flowent-0.3.2 → flowent-0.3.4}/src/flowent/agent.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from typing import cast
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict
@@ -44,6 +46,10 @@ Use tools deliberately:
 - Apply structured patches for file edits.
 - Run shell commands for diagnostics, builds, tests, and operations that require the local environment.
 - When a shell command needs to write outside the current workspace, declare each needed writable directory with sandbox_permissions set to with_additional_permissions and additional_permissions.file_system.write. Flowent reviews elevated permissions automatically, so keep the requested paths specific and tied to the task.
+- Use workflow tools when the user asks to view, inspect, run, create, or modify saved workflows. List workflows first when you need the workflow id. Read a workflow before modifying it.
+- When running a workflow and the user's current message contains one plain value to process, pass that content as the run_workflow input. When a workflow has multiple input nodes or the user provides separate values, use inputs with the exact input node ids from get_workflow.
+- When creating or updating a workflow, save a complete workflow object with valid node ids and edges. If saving fails, use the validation error as context and explain what needs to change.
+- Do not delete workflows. If the user asks to delete a workflow, say that you cannot do that directly.
 - Search the web only when current external information is needed.
 - Update the plan when a task has multiple meaningful steps.
 
@@ -315,6 +321,20 @@ async def run_agent_stream(
                 )
                 logger.log(TRACE_LEVEL, "Tool start item=%r", tool_item)
                 yield AgentStreamEvent(event="tool_start", data={"tool": tool_item})
+                tool_event_queue: asyncio.Queue[dict[str, object]] = asyncio.Queue()
+
+                async def emit_tool_event(
+                    data: dict[str, object],
+                    *,
+                    queue: asyncio.Queue[dict[str, object]] = tool_event_queue,
+                    tool_id: str = str(tool_item["id"]),
+                ) -> None:
+                    yield_data = {
+                        "id": tool_id,
+                        **data,
+                    }
+                    await queue.put(yield_data)
+
                 extra_result = (
                     await extra_tool_runner(tool_call.name, arguments)
                     if extra_tool_runner is not None
@@ -324,8 +344,12 @@ async def run_agent_stream(
                     extra_result if isinstance(extra_result, ToolResult) else None
                 )
                 if tool_result is None:
-                    context = ToolContext(cwd=cwd, web_searcher=web_searcher)
-                    tool_result = await (
+                    context = ToolContext(
+                        cwd=cwd,
+                        emit_event=emit_tool_event,
+                        web_searcher=web_searcher,
+                    )
+                    tool_task: asyncio.Future[ToolResult] = asyncio.ensure_future(
                         tool_runner(
                             tool_call.name,
                             arguments,
@@ -338,6 +362,41 @@ async def run_agent_stream(
                             context,
                         )
                     )
+                    pending_event_task: asyncio.Future[dict[str, object]] | None = None
+                    try:
+                        while True:
+                            if pending_event_task is None:
+                                pending_event_task = asyncio.create_task(
+                                    tool_event_queue.get()
+                                )
+                            done, _ = await asyncio.wait(
+                                {
+                                    cast(asyncio.Future[object], tool_task),
+                                    cast(asyncio.Future[object], pending_event_task),
+                                },
+                                return_when=asyncio.FIRST_COMPLETED,
+                            )
+                            if pending_event_task in done:
+                                yield AgentStreamEvent(
+                                    event="tool_update",
+                                    data=pending_event_task.result(),
+                                )
+                                pending_event_task = None
+                            if tool_task in done:
+                                if pending_event_task is not None:
+                                    pending_event_task.cancel()
+                                break
+                    except asyncio.CancelledError:
+                        tool_task.cancel()
+                        if pending_event_task is not None:
+                            pending_event_task.cancel()
+                        raise
+                    tool_result = await tool_task
+                    while not tool_event_queue.empty():
+                        yield AgentStreamEvent(
+                            event="tool_update",
+                            data=tool_event_queue.get_nowait(),
+                        )
                 result_content = tool_result_model_content(tool_result)
                 logger.debug(
                     "Tool call finished name=%s id=%s ok=%s",

flowent-0.3.4/src/flowent/agent_runtime.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from collections.abc import (
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Mapping,
+    Sequence,
+)
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+
+from flowent.agent import AgentContextUpdate, AgentStreamEvent, run_agent_stream
+from flowent.approval import (
+    ApprovalReviewRequest,
+    ApprovalTranscriptEntry,
+    review_approval_request,
+)
+from flowent.llm import ChatMessage, CompletionCallable, ProviderConnection
+from flowent.permissions import run_tool_with_path_permissions
+from flowent.storage import StateStore
+from flowent.tools import ToolContext, ToolResult, tool_specs
+from flowent.workflow_tools import (
+    WorkflowAgentTools,
+    workflow_tool_specs,
+    workflow_tool_title,
+)
+
+if TYPE_CHECKING:
+    from flowent.workflow_service import WorkflowService
+
+
+class AgentMcpManager(Protocol):
+    def tool_specs(self) -> Sequence[Mapping[str, object]]: ...
+
+    def tool_title(self, name: str) -> str | None: ...
+
+    async def run_tool(
+        self, name: str, arguments: dict[str, object]
+    ) -> ToolResult | None: ...
+
+
+@dataclass(frozen=True)
+class AgentRunResult:
+    content: str
+    thinking: str = ""
+
+
+class FlowentAgentRuntime:
+    def __init__(
+        self,
+        *,
+        chat_completion: CompletionCallable | None,
+        cwd: Path,
+        mcp_manager: AgentMcpManager | None,
+        store: StateStore,
+        workflow_service: WorkflowService | None,
+    ) -> None:
+        self.chat_completion = chat_completion
+        self.cwd = cwd
+        self.mcp_manager = mcp_manager
+        self.store = store
+        self.workflow_service = workflow_service
+
+    def extra_tool_specs(
+        self, *, include_workflow_tools: bool = True
+    ) -> list[Mapping[str, object]]:
+        return [
+            *(
+                workflow_tool_specs()
+                if include_workflow_tools and self.workflow_service is not None
+                else []
+            ),
+            *list(
+                self.mcp_manager.tool_specs() if self.mcp_manager is not None else []
+            ),
+        ]
+
+    def model_tool_specs(
+        self, *, include_workflow_tools: bool = True
+    ) -> list[Mapping[str, object]]:
+        return [
+            *tool_specs(),
+            *self.extra_tool_specs(include_workflow_tools=include_workflow_tools),
+        ]
+
+    def extra_tool_title(self, name: str) -> str | None:
+        return (
+            workflow_tool_title(name) if self.workflow_service is not None else None
+        ) or (
+            self.mcp_manager.tool_title(name) if self.mcp_manager is not None else None
+        )
+
+    def workflow_tools(self, workflow_depth: int = 0) -> WorkflowAgentTools | None:
+        if self.workflow_service is None:
+            return None
+        return WorkflowAgentTools(
+            self.workflow_service,
+            workflow_depth=workflow_depth,
+        )
+
+    async def run_extra_tool(
+        self,
+        name: str,
+        arguments: dict[str, object],
+        *,
+        include_workflow_tools: bool = True,
+        workflow_depth: int = 0,
+    ) -> ToolResult | None:
+        workflow_tools = (
+            self.workflow_tools(workflow_depth) if include_workflow_tools else None
+        )
+        if workflow_tools is not None:
+            workflow_result = await workflow_tools.run_tool(name, arguments)
+            if workflow_result is not None:
+                return workflow_result
+        if self.mcp_manager is None:
+            return None
+        return await self.mcp_manager.run_tool(name, arguments)
+
+    async def stream(
+        self,
+        *,
+        approval_transcript: Sequence[ApprovalTranscriptEntry] = (),
+        connection: ProviderConnection,
+        context_compactor: Callable[
+            [Sequence[Mapping[str, object]]], Awaitable[AgentContextUpdate | None]
+        ]
+        | None = None,
+        include_workflow_tools: bool = True,
+        messages: Sequence[ChatMessage | Mapping[str, object]],
+        user_request: str,
+        workflow_depth: int = 0,
+    ) -> AsyncIterator[AgentStreamEvent]:
+        transcript = list(approval_transcript)
+        request_messages = [
+            message.model_dump() if isinstance(message, ChatMessage) else dict(message)
+            for message in messages
+        ]
+
+        async def review_tool_approval(request: ApprovalReviewRequest):
+            return await review_approval_request(
+                connection,
+                request.model_copy(
+                    update={
+                        "transcript": transcript,
+                        "user_request": user_request,
+                    }
+                ),
+                completion=self.chat_completion,
+            )
+
+        async def tool_runner(
+            name: str,
+            arguments: dict[str, object],
+            context: ToolContext,
+        ) -> ToolResult:
+            return await run_tool_with_path_permissions(
+                name,
+                arguments,
+                context,
+                review_approval=review_tool_approval,
+                writable_paths=[
+                    Path(path.path) for path in self.store.read_writable_paths()
+                ],
+            )
+
+        async def extra_tool_runner(
+            name: str, arguments: dict[str, object]
+        ) -> ToolResult | None:
+            return await self.run_extra_tool(
+                name,
+                arguments,
+                include_workflow_tools=include_workflow_tools,
+                workflow_depth=workflow_depth,
+            )
+
+        async for event in run_agent_stream(
+            completion=self.chat_completion,
+            connection=connection,
+            context_compactor=context_compactor,
+            cwd=self.cwd,
+            extra_tool_runner=extra_tool_runner,
+            extra_tool_specs=self.extra_tool_specs(
+                include_workflow_tools=include_workflow_tools
+            ),
+            extra_tool_title=self.extra_tool_title,
+            messages=request_messages,
+            tool_runner=tool_runner,
+        ):
+            yield event
+
+    async def complete(
+        self,
+        *,
+        approval_transcript: Sequence[ApprovalTranscriptEntry] = (),
+        connection: ProviderConnection,
+        include_workflow_tools: bool = True,
+        messages: Sequence[ChatMessage | Mapping[str, object]],
+        user_request: str,
+        workflow_depth: int = 0,
+    ) -> AgentRunResult:
+        async for event in self.stream(
+            approval_transcript=approval_transcript,
+            connection=connection,
+            include_workflow_tools=include_workflow_tools,
+            messages=messages,
+            user_request=user_request,
+            workflow_depth=workflow_depth,
+        ):
+            if event.event != "done":
+                continue
+            message = event.data.get("message")
+            if isinstance(message, Mapping):
+                return AgentRunResult(
+                    content=str(message.get("content") or ""),
+                    thinking=str(message.get("thinking") or ""),
+                )
+        raise RuntimeError("Agent did not return a final response.")

{flowent-0.3.2 → flowent-0.3.4}/src/flowent/api_models.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from flowent.llm import ProviderFormat
 from flowent.storage import StoredMessage, StoredWritablePath
@@ -65,6 +65,14 @@ class WorkspaceClearResponse(BaseModel):
     usage_info: TokenUsageInfo | None = None
 
 
+class WorkflowRunRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    input: str = ""
+    inputs: dict[str, str] = Field(default_factory=dict)
+    timer_id: str = ""
+
+
 class AboutResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 

{flowent-0.3.2 → flowent-0.3.4}/src/flowent/app.py

@@ -23,6 +23,7 @@ from flowent.routes.workspace import register_workspace_routes
 from flowent.sandbox import ensure_sandbox_available
 from flowent.storage import StateStore
 from flowent.system_tools import ensure_ripgrep_available
+from flowent.workflow_service import WorkflowService
 from flowent.workspace.runtime import WorkspaceRuntime
 
 logger = logging.getLogger("flowent.app")
@@ -57,6 +58,12 @@ def create_app(
     store = StateStore()
     compact_provider = LocalSummaryCompactProvider()
     mcp_manager = McpManager(store=store, transport=mcp_transport)
+    workflow_service = WorkflowService(
+        chat_completion=chat_completion,
+        cwd=cwd,
+        mcp_manager=mcp_manager,
+        store=store,
+    )
 
     static_dir = frontend_static_directory().resolve(strict=False)
     logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
@@ -69,6 +76,7 @@ def create_app(
         cwd=cwd,
         mcp_manager=mcp_manager,
         store=store,
+        workflow_service=workflow_service,
     )
 
     telegram_bot_manager = TelegramBotManager(
@@ -121,8 +129,7 @@ def create_app(
     )
     register_workflow_routes(
         app,
-        chat_completion=chat_completion,
-        store=store,
+        workflow_service=workflow_service,
     )
     register_permission_routes(app, cwd=cwd, store=store)
     register_workspace_routes(app, runtime=runtime, store=store)

{flowent-0.3.2 → flowent-0.3.4}/src/flowent/permissions.py

@@ -14,6 +14,7 @@ from flowent.patch import affected_paths
 from flowent.sandbox import SandboxError, SandboxRunner, path_is_within
 from flowent.shell import shell_invocation
 from flowent.tools import (
+    CommandOutputCollector,
     ToolContext,
     ToolResult,
     command_tool_result,
@@ -305,17 +306,25 @@ async def shell_command_with_writable_paths(
     command = str(arguments["command"])
     timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
     invocation = shell_invocation(command)
+    collector = CommandOutputCollector(command, context.emit_event)
     result = await SandboxRunner(
         cwd=context.cwd,
         writable_roots=writable_paths,
-    ).run_async(invocation.args, env=invocation.env, timeout_seconds=timeout_seconds)
+    ).run_async(
+        invocation.args,
+        env=invocation.env,
+        on_stderr=collector.append_stderr,
+        on_stdout=collector.append_stdout,
+        timeout_seconds=timeout_seconds,
+    )
     ok = result.exit_code == 0
     return ToolResult(
         result=command_tool_result(
             command=command,
             exit_code=result.exit_code,
-            stderr=result.stderr,
-            stdout=result.stdout,
+            output_chunks=collector.output_chunks,
+            stderr=result.stderr or collector.stderr,
+            stdout=result.stdout or collector.stdout,
         ),
         ok=ok,
         title=f"Ran {command}",

flowent-0.3.4/src/flowent/routes/workflow_routes.py

@@ -0,0 +1,43 @@
+from fastapi import Body, FastAPI, HTTPException
+
+from flowent.api_models import WorkflowRunRequest
+from flowent.storage import StoredWorkflow
+from flowent.workflow_service import WorkflowService
+from flowent.workflows import WorkflowRunResponse
+
+OPTIONAL_WORKFLOW_RUN_BODY = Body(default=None)
+
+
+def register_workflow_routes(
+    app: FastAPI,
+    *,
+    workflow_service: WorkflowService,
+) -> None:
+    @app.put("/api/workflows")
+    async def save_workflow(workflow: StoredWorkflow) -> StoredWorkflow:
+        try:
+            return workflow_service.save_workflow(workflow)
+        except ValueError as error:
+            raise HTTPException(status_code=400, detail=str(error)) from error
+
+    @app.delete("/api/workflows/{workflow_id}")
+    async def delete_workflow(workflow_id: str) -> dict[str, bool]:
+        workflow_service.store.delete_workflow(workflow_id)
+        return {"ok": True}
+
+    @app.post("/api/workflows/{workflow_id}/run")
+    async def run_workflow(
+        workflow_id: str,
+        request: WorkflowRunRequest | None = OPTIONAL_WORKFLOW_RUN_BODY,
+    ) -> WorkflowRunResponse:
+        run_request = request or WorkflowRunRequest()
+        try:
+            return await workflow_service.run_workflow(
+                workflow_id,
+                default_input=run_request.input,
+                input_values=run_request.inputs,
+                timer_node_id=run_request.timer_id,
+            )
+        except ValueError as error:
+            status_code = 404 if str(error) == "Workflow not found." else 400
+            raise HTTPException(status_code=status_code, detail=str(error)) from error

{flowent-0.3.2 → flowent-0.3.4}/src/flowent/sandbox.py

@@ -8,7 +8,7 @@ import shutil
 import signal
 import subprocess
 import tempfile
-from collections.abc import Mapping
+from collections.abc import Awaitable, Callable, Mapping
 from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
@@ -34,6 +34,9 @@ class SandboxError(RuntimeError):
     pass
 
 
+OutputCallback = Callable[[str], Awaitable[None]]
+
+
 SANDBOX_INSTALL_HINT = (
     "Install bubblewrap and try again. Debian/Ubuntu: "
     "sudo apt-get install bubblewrap. Fedora: sudo dnf install bubblewrap. "
@@ -213,6 +216,29 @@ class SandboxRunner:
             return value.decode(errors="replace")
         return value
 
+    async def _read_stream(
+        self,
+        stream: asyncio.StreamReader | None,
+        callback: OutputCallback | None,
+    ) -> str:
+        if stream is None:
+            return ""
+        chunks: list[str] = []
+        remaining = self.output_limit
+        while True:
+            chunk = await stream.read(4096)
+            if not chunk:
+                break
+            text = self._text_output(chunk)
+            if remaining <= 0:
+                continue
+            limited = text[:remaining]
+            remaining -= len(limited)
+            chunks.append(limited)
+            if callback is not None and limited:
+                await callback(limited)
+        return "".join(chunks)
+
     def __init__(
         self,
         *,
@@ -334,6 +360,8 @@ class SandboxRunner:
         *,
         env: dict[str, str] | None = None,
         input_text: str | None = None,
+        on_stderr: OutputCallback | None = None,
+        on_stdout: OutputCallback | None = None,
         timeout_seconds: float | None = None,
     ) -> CommandResult:
         process_env = build_shell_environment(env)
@@ -346,22 +374,26 @@ class SandboxRunner:
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
+        stdout_task = asyncio.create_task(self._read_stream(process.stdout, on_stdout))
+        stderr_task = asyncio.create_task(self._read_stream(process.stderr, on_stderr))
+        if input_text is not None and process.stdin is not None:
+            process.stdin.write(input_text.encode())
+            await process.stdin.drain()
+            process.stdin.close()
         try:
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(
-                    input_text.encode() if input_text is not None else None
-                ),
-                timeout=timeout_seconds or self.timeout_seconds,
+            await asyncio.wait_for(
+                process.wait(), timeout=timeout_seconds or self.timeout_seconds
             )
         except TimeoutError as error:
             with suppress(ProcessLookupError):
                 os.killpg(process.pid, signal.SIGKILL)
-            stdout, stderr = await process.communicate()
+            await process.wait()
+            stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
             return CommandResult(
                 command=" ".join(command),
                 exit_code=124,
                 stderr=str(error) or "Command timed out.",
-                stdout=self._text_output(stdout)[: self.output_limit],
+                stdout=stdout,
             )
         except asyncio.CancelledError:
             with suppress(ProcessLookupError):
@@ -372,13 +404,16 @@ class SandboxRunner:
                 with suppress(ProcessLookupError):
                     os.killpg(process.pid, signal.SIGKILL)
                 await process.wait()
+            for task in [stdout_task, stderr_task]:
+                task.cancel()
             raise
 
+        stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
         return CommandResult(
             command=" ".join(command),
             exit_code=process.returncode or 0,
-            stderr=self._text_output(stderr)[: self.output_limit],
-            stdout=self._text_output(stdout)[: self.output_limit],
+            stderr=stderr,
+            stdout=stdout,
         )
 
     async def run_async(
@@ -387,6 +422,8 @@ class SandboxRunner:
         *,
         env: dict[str, str] | None = None,
         input_text: str | None = None,
+        on_stderr: OutputCallback | None = None,
+        on_stdout: OutputCallback | None = None,
         timeout_seconds: float | None = None,
     ) -> CommandResult:
         sandbox_command = self.build_command(command)
@@ -405,22 +442,26 @@ class SandboxRunner:
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
+        stdout_task = asyncio.create_task(self._read_stream(process.stdout, on_stdout))
+        stderr_task = asyncio.create_task(self._read_stream(process.stderr, on_stderr))
+        if input_text is not None and process.stdin is not None:
+            process.stdin.write(input_text.encode())
+            await process.stdin.drain()
+            process.stdin.close()
         try:
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(
-                    input_text.encode() if input_text is not None else None
-                ),
-                timeout=timeout_seconds or self.timeout_seconds,
+            await asyncio.wait_for(
+                process.wait(), timeout=timeout_seconds or self.timeout_seconds
             )
         except TimeoutError as error:
             with suppress(ProcessLookupError):
                 os.killpg(process.pid, signal.SIGKILL)
-            stdout, stderr = await process.communicate()
+            await process.wait()
+            stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
             return CommandResult(
                 command=" ".join(command),
                 exit_code=124,
                 stderr=str(error) or "Command timed out.",
-                stdout=self._text_output(stdout)[: self.output_limit],
+                stdout=stdout,
             )
         except asyncio.CancelledError:
             with suppress(ProcessLookupError):
@@ -431,14 +472,17 @@ class SandboxRunner:
                 with suppress(ProcessLookupError):
                     os.killpg(process.pid, signal.SIGKILL)
                 await process.wait()
+            for task in [stdout_task, stderr_task]:
+                task.cancel()
             raise
         finally:
             if sandbox_command.seccomp_file is not None:
                 sandbox_command.seccomp_file.close()
 
+        stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
         return CommandResult(
             command=" ".join(command),
             exit_code=process.returncode or 0,
-            stderr=self._text_output(stderr)[: self.output_limit],
-            stdout=self._text_output(stdout)[: self.output_limit],
+            stderr=stderr,
+            stdout=stdout,
         )