switchplane 0.3.0__tar.gz → 0.4.0__tar.gz

switchplane-0.4.0/.github/workflows/www.yml

@@ -0,0 +1,53 @@
+name: Deploy docs site to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "www/**"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+          cache-dependency-path: www/package-lock.json
+
+      - name: Install dependencies
+        working-directory: www
+        run: npm ci
+
+      - name: Build
+        working-directory: www
+        run: npm run build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: www/dist
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

{switchplane-0.3.0 → switchplane-0.4.0}/CLAUDE.md

@@ -33,6 +33,12 @@ src/switchplane/           # Main package (pip-installable)
 
   mcp.py                   # MCP client lifecycle: McpSession, McpManager, LangChain tool wrapper
 
+  _util.py                 # Shared constants (MAX_MESSAGE_SIZE)
+  llm.py                   # LLM provider routing (ChatAnthropic/OpenAI/Google via model prefix)
+  logging.py               # structlog configuration
+  oauth.py                 # OAuth client for MCP HTTP servers (PKCE flows)
+  scaffold.py              # `switchplane init` project scaffolding
+
 examples/hello/        # Simple LangGraph graph (get_user → say_hello)
 examples/weather/      # Long-running polling task (Open-Meteo weather watch, @command for coordinates)
 examples/devops/       # Ops review: deterministic pandas analysis + LLM summary
@@ -111,7 +117,7 @@ click, pydantic v2, aiosqlite, langgraph, prompt_toolkit, structlog. Optional: `
 
 **CLI ↔ Control Plane:** Unix socket at `~/.{app_name}/runtime.sock`. Messages are 4-byte big-endian length prefix + JSON body. Types: `CliRequest` / `CliResponse`.
 
-**Agent ↔ Control Plane:** Bidirectional over a per-agent Unix socketpair (`socket.socketpair(AF_UNIX)`). The CP creates the pair, passes one fd to the child via `--ipc-fd` + `pass_fds`. Same 4-byte length-prefixed JSON framing as CLI protocol. CP sends `AgentCommand`, agent sends `AgentEvent`. This allows mid-execution cancel/shutdown — the agent runs a command listener concurrently with task execution. stdout/stderr are freed for normal logging.
+**Agent ↔ Control Plane:** Bidirectional over a per-agent Unix socketpair (`socket.socketpair(AF_UNIX)`). The CP creates the pair, passes one fd to the child via `--ipc-fd` + `pass_fds`. Same 4-byte length-prefixed JSON framing as CLI protocol. CP sends `AgentCommand`, agent sends `AgentEvent`. Agents can also send `AgentRequest` to the CP and receive `AgentResponse` — used for cross-task operations (submit, query, notify). This allows mid-execution cancel/shutdown — the agent runs a command listener concurrently with task execution. stdout/stderr are freed for normal logging.
 
 ## Database
 
@@ -124,11 +130,25 @@ SQLite at `~/.{app_name}/state.db` with WAL mode. Tables: `agents`, `tasks`, `ev
 3. Declare parameters as class attributes using `Field()` from `switchplane` (re-exported from Pydantic). Parameters are validated before execution and set as instance attributes.
 4. Implement `async def run(self, ctx: AgentContext)` — access params via `self.<param>`, build a LangGraph `StateGraph`, compile, `ainvoke`, then `ctx.complete(result)`
 5. Optionally add `@command`-decorated methods for runtime commands on long-running tasks. Command parameters are typed and auto-coerced.
-6. Discovery auto-registers the task from the `tasks/` subpackage — no need to declare it in `AgentSpec`
+6. Optionally declare `mcp_servers: ClassVar[list[str]] = ["server-name"]` on the task class to specify which MCP servers the task needs. Only declared servers are started for that task. If not set, all agent-level servers are used.
+7. Discovery auto-registers the task from the `tasks/` subpackage — no need to declare it in `AgentSpec`
 
 ## MCP integration
 
-MCP servers are registered at the app level via `McpServerConfig` (provide `command` for stdio, `url` for HTTP — transport is inferred). Agents declare which servers they need via `AgentSpec.mcp_servers`. The agent runtime manages client lifecycle (spawning stdio processes or connecting to HTTP endpoints) and exposes tools via `ctx.mcp` (raw sessions) and `ctx.mcp_tools()` (LangChain `StructuredTool` wrappers). MCP is an optional dependency: `pip install switchplane[mcp]`.
+MCP servers are registered at the app level via `McpServerConfig` (provide `command` for stdio, `url` for HTTP — transport is inferred). Agents declare which servers they need via `AgentSpec.mcp_servers`. The agent runtime manages client lifecycle (spawning stdio processes or connecting to HTTP endpoints) and exposes tools via `ctx.mcp` (raw sessions) and `ctx.mcp_tools()` (LangChain `StructuredTool` wrappers). MCP is an optional dependency: `pip install switchplane[mcp]`. Tasks can also declare `mcp_servers` at the class level to restrict which servers are started for that specific task (instead of inheriting all servers from the agent).
+
+## Cross-task coordination
+
+Tasks can spawn child tasks, wait for their completion, and send notifications to sibling tasks via `AgentContext`:
+
+- `ctx.submit_task(agent_name, task_name, params)` → submits a child task (linked via `parent_task_id`), returns the new `task_id`
+- `ctx.get_task(task_id)` → returns current task record and events
+- `ctx.wait_for_task(task_id)` → polls until terminal state, returns task record
+- `ctx.wait_for_tasks(task_ids)` → parallel wait on multiple tasks
+- `ctx.notify_task(task_id, payload)` → send a notification to another running task
+- `ctx.wait_for_notification(timeout)` → block until a notification arrives
+
+These requests travel over the existing agent↔CP socketpair as `AgentRequest`/`AgentResponse` messages. The control plane routes submissions and notifications across agents.
 
 ## Checkpoint and resume
 

switchplane-0.3.0/README.md → switchplane-0.4.0/PKG-INFO

@@ -1,3 +1,41 @@
+Metadata-Version: 2.4
+Name: switchplane
+Version: 0.4.0
+Summary: Python runtime control plane for agent-based task execution, LangGraph-native
+Project-URL: Homepage, https://github.com/salesforce-misc/switchplane
+Project-URL: Repository, https://github.com/salesforce-misc/switchplane
+Project-URL: Issues, https://github.com/salesforce-misc/switchplane/issues
+Author-email: Demian Brecht <dbrecht@salesforce.com>
+License: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: click<9,>=8.3
+Requires-Dist: langgraph>=1.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: pydantic<3,>=2.0
+Requires-Dist: structlog>=24.0
+Provides-Extra: llm
+Requires-Dist: langchain-core>=0.3; extra == 'llm'
+Requires-Dist: rich>=13.0; extra == 'llm'
+Provides-Extra: mcp
+Requires-Dist: langchain-core>=0.3; extra == 'mcp'
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Requires-Dist: rich>=13.0; extra == 'mcp'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest-cov>=4.0; extra == 'test'
+Requires-Dist: pytest-xdist>=3.5; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Requires-Dist: ruff>=0.9; extra == 'test'
+Description-Content-Type: text/markdown
+
 # Switchplane
 
 Most agent frameworks hand everything to the LLM and hope for the best. Switchplane takes a different position:
@@ -521,6 +559,19 @@ agent_spec = AgentSpec(
 )
 ```
 
+**Declare MCP servers on a task (optional):**
+
+Tasks can override the agent-level default by declaring which specific servers they need. Only declared servers are started for that task:
+
+```python
+class MyTask(Task):
+    name = "analyze"
+    mcp_servers = ["my-tools"]  # Only start this server, not all agent servers
+
+    async def run(self, ctx: AgentContext) -> None:
+        tools = await ctx.mcp_tools()  # Only tools from "my-tools"
+```
+
 **Use MCP tools in your task:**
 
 ```python
@@ -625,6 +676,44 @@ llm_with_tools = llm.bind_tools(tools)
 
 `Shell` uses `asyncio.create_subprocess_exec` (no shell interpretation), so arguments are never passed through a shell. The allowlist and path validation add defense-in-depth when LLM-generated values flow into command arguments.
 
+For a general-purpose shell tool, `bash_tool()` returns a single `StructuredTool` that parses commands with `shlex` and validates against the allowlist. Working directory is locked to `allowed_paths[0]`, output is truncated to `max_output_chars` (default 30,000 characters). `agent_tools()` returns a minimal coding-focused set: bash + write_file + edit_file.
+
+```python
+# General-purpose bash tool
+bash = shell.bash_tool()
+
+# Minimal set for coding agents: bash + write_file + edit_file
+tools = shell.agent_tools()
+```
+
+### Cross-task coordination
+
+Tasks can spawn child tasks, wait for their completion, and send notifications to sibling tasks. Child tasks are linked via `parent_task_id`. Requests travel over the existing agent-CP socketpair as `AgentRequest`/`AgentResponse` messages.
+
+```python
+async def run(self, ctx: AgentContext) -> None:
+    # Spawn a child task (returns immediately with task_id)
+    child_id = await ctx.submit_task("worker", "process", {"chunk": 1})
+
+    # Wait for it to reach a terminal state
+    result = await ctx.wait_for_task(child_id)
+
+    # Or spawn multiple and wait in parallel
+    ids = [
+        await ctx.submit_task("worker", "process", {"chunk": i})
+        for i in range(3)
+    ]
+    results = await ctx.wait_for_tasks(ids)
+
+    # Send a notification to another running task
+    await ctx.notify_task(other_task_id, {"status": "ready"})
+
+    # Block until a notification arrives (or timeout)
+    notification = await ctx.wait_for_notification(timeout=60.0)
+```
+
+`wait_for_task` polls until the child reaches a terminal state (completed, failed, cancelled). `wait_for_notification` wakes immediately when a notification arrives -- useful for event-driven coordination between long-running tasks.
+
 ### Checkpoint and resume
 
 Tasks can opt into checkpointing so that failed or cancelled runs can be resumed from the last completed graph node. Switchplane provides a LangGraph-compatible checkpoint saver backed by the app's SQLite database. Pass it to `graph.compile()` and use `ctx.task_id` as the thread ID:

switchplane-0.3.0/PKG-INFO → switchplane-0.4.0/README.md

@@ -1,39 +1,3 @@
-Metadata-Version: 2.4
-Name: switchplane
-Version: 0.3.0
-Summary: Python runtime control plane for agent-based task execution, LangGraph-native
-Project-URL: Homepage, https://github.com/salesforce-misc/switchplane
-Project-URL: Repository, https://github.com/salesforce-misc/switchplane
-Project-URL: Issues, https://github.com/salesforce-misc/switchplane/issues
-Author-email: Demian Brecht <dbrecht@salesforce.com>
-License: Apache-2.0
-License-File: LICENSE
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Requires-Python: >=3.12
-Requires-Dist: aiosqlite>=0.20
-Requires-Dist: click<9,>=8.3
-Requires-Dist: langgraph>=1.0
-Requires-Dist: prompt-toolkit>=3.0
-Requires-Dist: pydantic<3,>=2.0
-Requires-Dist: structlog>=24.0
-Provides-Extra: llm
-Requires-Dist: langchain-core>=0.3; extra == 'llm'
-Provides-Extra: mcp
-Requires-Dist: langchain-core>=0.3; extra == 'mcp'
-Requires-Dist: mcp>=1.0; extra == 'mcp'
-Provides-Extra: test
-Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
-Requires-Dist: pytest-cov>=4.0; extra == 'test'
-Requires-Dist: pytest-xdist>=3.5; extra == 'test'
-Requires-Dist: pytest>=7.0; extra == 'test'
-Requires-Dist: ruff>=0.9; extra == 'test'
-Description-Content-Type: text/markdown
-
 # Switchplane
 
 Most agent frameworks hand everything to the LLM and hope for the best. Switchplane takes a different position:
@@ -557,6 +521,19 @@ agent_spec = AgentSpec(
 )
 ```
 
+**Declare MCP servers on a task (optional):**
+
+Tasks can override the agent-level default by declaring which specific servers they need. Only declared servers are started for that task:
+
+```python
+class MyTask(Task):
+    name = "analyze"
+    mcp_servers = ["my-tools"]  # Only start this server, not all agent servers
+
+    async def run(self, ctx: AgentContext) -> None:
+        tools = await ctx.mcp_tools()  # Only tools from "my-tools"
+```
+
 **Use MCP tools in your task:**
 
 ```python
@@ -661,6 +638,44 @@ llm_with_tools = llm.bind_tools(tools)
 
 `Shell` uses `asyncio.create_subprocess_exec` (no shell interpretation), so arguments are never passed through a shell. The allowlist and path validation add defense-in-depth when LLM-generated values flow into command arguments.
 
+For a general-purpose shell tool, `bash_tool()` returns a single `StructuredTool` that parses commands with `shlex` and validates against the allowlist. Working directory is locked to `allowed_paths[0]`, output is truncated to `max_output_chars` (default 30,000 characters). `agent_tools()` returns a minimal coding-focused set: bash + write_file + edit_file.
+
+```python
+# General-purpose bash tool
+bash = shell.bash_tool()
+
+# Minimal set for coding agents: bash + write_file + edit_file
+tools = shell.agent_tools()
+```
+
+### Cross-task coordination
+
+Tasks can spawn child tasks, wait for their completion, and send notifications to sibling tasks. Child tasks are linked via `parent_task_id`. Requests travel over the existing agent-CP socketpair as `AgentRequest`/`AgentResponse` messages.
+
+```python
+async def run(self, ctx: AgentContext) -> None:
+    # Spawn a child task (returns immediately with task_id)
+    child_id = await ctx.submit_task("worker", "process", {"chunk": 1})
+
+    # Wait for it to reach a terminal state
+    result = await ctx.wait_for_task(child_id)
+
+    # Or spawn multiple and wait in parallel
+    ids = [
+        await ctx.submit_task("worker", "process", {"chunk": i})
+        for i in range(3)
+    ]
+    results = await ctx.wait_for_tasks(ids)
+
+    # Send a notification to another running task
+    await ctx.notify_task(other_task_id, {"status": "ready"})
+
+    # Block until a notification arrives (or timeout)
+    notification = await ctx.wait_for_notification(timeout=60.0)
+```
+
+`wait_for_task` polls until the child reaches a terminal state (completed, failed, cancelled). `wait_for_notification` wakes immediately when a notification arrives -- useful for event-driven coordination between long-running tasks.
+
 ### Checkpoint and resume
 
 Tasks can opt into checkpointing so that failed or cancelled runs can be resumed from the last completed graph node. Switchplane provides a LangGraph-compatible checkpoint saver backed by the app's SQLite database. Pass it to `graph.compile()` and use `ctx.task_id` as the thread ID:

{switchplane-0.3.0 → switchplane-0.4.0}/examples/chatbot/chatbot/agents/bot/tasks/chat.py

@@ -67,7 +67,7 @@ class ChatTask(Task):
         # First turn: LLM responds to "Hello!", then graph interrupts at wait_for_user
         result = await graph.ainvoke(initial_state, config)
         last_msg = result["messages"][-1]
-        ctx.progress(f"Assistant: {last_msg.content}")
+        ctx.stream_flush(last_msg.content)
 
         # Chat loop
         while not self._ending:
@@ -78,6 +78,6 @@ class ChatTask(Task):
             # Resume the graph: wait_for_user returns with user text, then respond runs
             result = await graph.ainvoke(Command(resume=user_input), config)
             last_msg = result["messages"][-1]
-            ctx.progress(f"Assistant: {last_msg.content}")
+            ctx.stream_flush(last_msg.content)
 
         ctx.complete({"turns": len(result.get("messages", [])) // 2})

{switchplane-0.3.0 → switchplane-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "switchplane"
-version = "0.3.0"
+version = "0.4.0"
 description = "Python runtime control plane for agent-based task execution, LangGraph-native"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -36,7 +36,7 @@ Repository = "https://github.com/salesforce-misc/switchplane"
 Issues = "https://github.com/salesforce-misc/switchplane/issues"
 
 [project.optional-dependencies]
-llm = ["langchain-core>=0.3"]
+llm = ["langchain-core>=0.3", "rich>=13.0"]
 mcp = ["mcp>=1.0", "switchplane[llm]"]
 test = ["pytest>=7.0", "pytest-asyncio>=0.23", "pytest-cov>=4.0", "pytest-xdist>=3.5", "ruff>=0.9"]
 

{switchplane-0.3.0 → switchplane-0.4.0}/src/switchplane/agent_runtime.py

@@ -188,6 +188,28 @@ class AgentContext:
         )
         _write_message_sync(self._sock, event.model_dump_json().encode())
 
+    def stream_token(self, text: str) -> None:
+        """Emit a streaming text chunk (ephemeral, not persisted)."""
+        self.emit("stream.chunk", {"text": text})
+
+    def stream_flush(self, text: str) -> None:
+        """End a streaming sequence. The text is the final complete output that replaces accumulated chunks."""
+        self.emit("stream.flush", {"text": text})
+
+    def tool_invoke(self, name: str, summary: str = "") -> None:
+        """Emit a tool invocation event."""
+        payload: dict[str, Any] = {"name": name}
+        if summary:
+            payload["summary"] = summary
+        self.emit("tool.invoke", payload)
+
+    def tool_result(self, name: str, summary: str = "") -> None:
+        """Emit a tool result event."""
+        payload: dict[str, Any] = {"name": name}
+        if summary:
+            payload["summary"] = summary
+        self.emit("tool.result", payload)
+
     def progress(self, message: str, detail: str | list[str] | None = None, **extra) -> None:
         payload: dict[str, Any] = {"message": message, **extra}
         if detail is not None:
@@ -501,6 +523,7 @@ async def _start_checkpointer(ctx: AgentContext) -> None:
         ctx._db_conn = await aiosqlite.connect(ctx._db_path)
         ctx._db_conn.row_factory = aiosqlite.Row
         await ctx._db_conn.execute("PRAGMA journal_mode=WAL")
+        await ctx._db_conn.execute("PRAGMA busy_timeout=5000")
         saver = SqliteCheckpointSaver(ctx._db_conn)
         await saver.setup()
         ctx._checkpointer = saver

{switchplane-0.3.0 → switchplane-0.4.0}/src/switchplane/cli.py

@@ -590,6 +590,31 @@ def _follow_task(task_id: str, send_request) -> None:
 
 def _print_event(event: dict) -> None:
     """Format and print a single event using the shared renderer."""
+    etype = event.get("event_type", "")
+
+    # stream.chunk: print inline without newline
+    if etype == "stream.chunk":
+        text = event.get("payload", {}).get("text", "")
+        sys.stdout.write(text)
+        sys.stdout.flush()
+        return
+
+    # stream.flush: end the streaming line, then render final text as markdown
+    if etype == "stream.flush":
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+        text = event.get("payload", {}).get("text", "")
+        if text.strip():
+            try:
+                from rich.console import Console as RichConsole
+                from rich.markdown import Markdown
+
+                RichConsole().print(Markdown(text))
+            except ImportError:
+                for part in text.split("\n"):
+                    click.echo(f"  {part}")
+        return
+
     for line in fmt.render_event(event):
         text = "".join(seg[1] for seg in line.segments)
         is_dim = all(s in (fmt.DIM, fmt.TS) for s, _ in line.segments)

{switchplane-0.3.0 → switchplane-0.4.0}/src/switchplane/fmt.py

@@ -4,7 +4,7 @@ import json
 from dataclasses import dataclass, field
 
 # Semantic style names — consumers map these to their output format
-TS = "ts"
+TS = "ts"  # kept for backward compat; no longer emitted
 INFO = "info"
 DIM = "dim"
 PROGRESS = "progress"
@@ -12,6 +12,10 @@ SUCCESS = "success"
 WARN = "warn"
 ERROR = "error"
 LOG = "log"
+STREAM = "stream"
+TOOL = "tool"
+
+_MAX_DETAIL_LINES = 20
 
 
 @dataclass
@@ -28,15 +32,13 @@ def render_event(event: dict) -> list[EventLine]:
     style constants defined in this module. Consumers map these to
     their output format (click.echo, prompt_toolkit styled tuples, etc.).
     """
-    raw_ts = event.get("timestamp", "")
-    ts = raw_ts.split("T")[1].split(".")[0] if "T" in raw_ts else raw_ts
     etype = event.get("event_type", "")
     payload = event.get("payload", {})
 
     lines: list[EventLine] = []
 
     def main_line(style: str, msg: str) -> None:
-        lines.append(EventLine([(TS, f"[{ts}] "), (style, msg)]))
+        lines.append(EventLine([(style, msg)]))
 
     def continuation(style: str, text: str) -> None:
         lines.append(EventLine([(style, f"  {text}")]))
@@ -49,8 +51,14 @@ def render_event(event: dict) -> list[EventLine]:
         main_line(PROGRESS, parts[0])
         for cont in parts[1:]:
             continuation(PROGRESS, cont)
-        for det in tree(payload.get("detail", [])):
-            continuation(DIM, det)
+        detail_lines = tree(payload.get("detail", []))
+        if len(detail_lines) > _MAX_DETAIL_LINES:
+            for det in detail_lines[:_MAX_DETAIL_LINES]:
+                continuation(DIM, det)
+            continuation(DIM, f"[+{len(detail_lines) - _MAX_DETAIL_LINES} lines]")
+        else:
+            for det in detail_lines:
+                continuation(DIM, det)
     elif etype == "task.completed":
         main_line(SUCCESS, "Task completed")
     elif etype == "task.cancelled":
@@ -86,6 +94,20 @@ def render_event(event: dict) -> list[EventLine]:
         main_line(style, parts[0])
         for cont in parts[1:]:
             continuation(style, cont)
+    elif etype == "tool.invoke":
+        name = payload.get("name", "unknown")
+        summary = payload.get("summary", "")
+        if summary:
+            main_line(TOOL, f"\u25b8 {name}: {summary}")
+        else:
+            main_line(TOOL, f"\u25b8 {name}")
+    elif etype == "tool.result":
+        name = payload.get("name", "unknown")
+        summary = payload.get("summary", "")
+        if summary:
+            main_line(TOOL, f"\u25c2 {name}: {summary}")
+        else:
+            main_line(TOOL, f"\u25c2 {name}")
     elif etype == "task.command_result":
         action = payload.get("action", "unknown")
         result = payload.get("result", {})

{switchplane-0.3.0 → switchplane-0.4.0}/src/switchplane/protocol.py

@@ -59,6 +59,10 @@ class AgentEvent(BaseModel):
         "checkpoint.save",
         "log",
         "task.command_result",
+        "stream.chunk",
+        "stream.flush",
+        "tool.invoke",
+        "tool.result",
     ]
     task_id: str
     payload: dict[str, Any] = Field(default_factory=dict)

{switchplane-0.3.0 → switchplane-0.4.0}/src/switchplane/subprocess_manager.py

@@ -307,6 +307,10 @@ class SubprocessManager:
 
     async def _handle_event(self, event: AgentEvent) -> int:
         """Process an event from an agent and update persistence. Returns event_id."""
+        # stream.chunk events are ephemeral — skip DB persistence
+        if event.type == "stream.chunk":
+            return 0
+
         event_id = await self.store.add_event(event.task_id, event.type, event.payload)
 
         match event.type: