synapse-orch-ai 1.8.3 → 1.8.5

package/backend/core/config.py

@@ -129,7 +129,7 @@ def load_settings():
         file_settings = {}
     else:
         try:
-            with open(SETTINGS_FILE, 'r') as f:
+            with open(SETTINGS_FILE, 'r', encoding="utf-8") as f:
                 file_settings = json.load(f)
         except Exception as e:
             print(f"DEBUG: Error loading settings: {e}")
@@ -168,7 +168,7 @@ def get_or_create_jwt_secret() -> str:
 
     if env_file.exists():
         try:
-            for line in env_file.read_text().splitlines():
+            for line in env_file.read_text(encoding="utf-8").splitlines():
                 line = line.strip()
                 if line.startswith(f"{var}=") and len(line) > len(f"{var}="):
                     val = line.split("=", 1)[1].strip()

package/backend/core/json_store.py

@@ -32,7 +32,7 @@ class JsonStore:
             if not os.path.exists(self.path):
                 return self.default_factory()
             try:
-                with open(self.path, "r") as f:
+                with open(self.path, "r", encoding="utf-8") as f:
                     data = json.load(f)
                 if self._cache_ttl > 0:
                     self._cache = data
@@ -43,7 +43,7 @@ class JsonStore:
 
     def save(self, data):
         with self._lock:
-            with open(self.path, "w") as f:
+            with open(self.path, "w", encoding="utf-8") as f:
                 json.dump(data, f, indent=4)
             if self._cache_ttl > 0:
                 self._cache = data

package/backend/core/mcp_client.py

@@ -69,14 +69,14 @@ class FileTokenStorage(TokenStorage):
         if not os.path.exists(path):
             return None
         try:
-            with open(path) as f:
+            with open(path, encoding="utf-8") as f:
                 return json.load(f)
         except Exception:
             return None
 
     def _write(self, path: str, data: dict):
         os.makedirs(MCP_TOKENS_DIR, exist_ok=True)
-        with open(path, "w") as f:
+        with open(path, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
 
     async def get_tokens(self) -> Optional[OAuthToken]:
@@ -181,7 +181,7 @@ class MCPClientManager:
         if not os.path.exists(MCP_SERVERS_FILE):
             return []
         try:
-            with open(MCP_SERVERS_FILE) as f:
+            with open(MCP_SERVERS_FILE, encoding="utf-8") as f:
                 return json.load(f)
         except Exception as e:
             print(f"Error loading MCP servers config: {e}")
@@ -189,7 +189,7 @@ class MCPClientManager:
 
     def save_servers(self):
         os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
-        with open(MCP_SERVERS_FILE, "w") as f:
+        with open(MCP_SERVERS_FILE, "w", encoding="utf-8") as f:
             json.dump(self.servers_config, f, indent=4)
 
     def _set_status(self, name: str, status: str):

package/backend/core/messaging/store.py

@@ -17,7 +17,7 @@ def _load_raw() -> list[dict]:
     if not os.path.exists(CHANNELS_FILE):
         return []
     try:
-        with open(CHANNELS_FILE, "r") as f:
+        with open(CHANNELS_FILE, "r", encoding="utf-8") as f:
             data = json.load(f)
         return data if isinstance(data, list) else []
     except Exception:
@@ -26,7 +26,7 @@ def _load_raw() -> list[dict]:
 
 def _save_raw(data: list[dict]) -> None:
     os.makedirs(DATA_DIR, exist_ok=True)
-    with open(CHANNELS_FILE, "w") as f:
+    with open(CHANNELS_FILE, "w", encoding="utf-8") as f:
         json.dump(data, f, indent=2)
 
 

package/backend/core/orchestration/engine.py

@@ -182,12 +182,18 @@ class OrchestrationEngine:
                 # This properly interrupts a stuck session.call_tool() inside
                 # the executor when the step deadline is reached.
                 #
-                # IMPORTANT: never yield human_input_required inside the
-                # fail_after scope. Python's GC finalizer runs aclose() on
-                # abandoned async generators in a NEW asyncio Task; if a
-                # cancel scope is active at the suspension point, anyio raises
-                # "cancel scope in a different task". We break out of the scope
-                # cleanly (in the current task) and yield the event below.
+                # IMPORTANT: this scope stays open across the yields below, so
+                # this generator must be advanced — and closed — from a single
+                # task, or anyio raises "cancel scope in a different task".
+                # core.orchestration.runner is what guarantees that; every
+                # entry point runs us through it (issue #356). Do not drive
+                # the engine directly from a task-per-pull consumer.
+                #
+                # human_input_required is still yielded outside the scope: the
+                # generator is abandoned at that point, and Python's GC
+                # finalizer runs aclose() on abandoned async generators in a
+                # NEW asyncio Task. We break out of the scope cleanly (in the
+                # current task) and yield the event below.
                 human_input_event: dict | None = None
                 try:
                     with anyio.fail_after(step_timeout):

package/backend/core/orchestration/runner.py

@@ -0,0 +1,70 @@
+"""Single-task runner for orchestration engine streams.
+
+The engine holds anyio cancel scopes across `yield`s (the per-step timeout at
+`engine._execute_loop`). anyio binds a cancel scope to the task that entered
+it, so the engine's generator must be advanced -- and closed -- from ONE task,
+whatever the HTTP layer does with the events. A consumer that pulls each event
+in a fresh task raises "Attempted to exit cancel scope in a different task"
+(issue #356).
+
+Every orchestration entry point goes through here, so the launch path can no
+longer change how the engine is driven.
+"""
+import asyncio
+from typing import AsyncGenerator
+
+# Live in-process runs, keyed by run_id. The cancel endpoint cancels the task
+# to interrupt an in-progress await; the run-status endpoint consults it to
+# report a run that is still inside its first step (no checkpoint yet).
+_active_tasks: dict[str, asyncio.Task] = {}
+
+# Queue marker meaning "the engine generator is exhausted".
+SENTINEL = object()
+
+
+def spawn_engine_run(agen, run_id: str) -> tuple[asyncio.Task, asyncio.Queue]:
+    """Advance `agen` in one dedicated task, returning (task, queue).
+
+    The task is detached: it runs to completion even if nobody drains the
+    queue, so a client disconnect never kills a run. Only the cancel endpoint
+    stops it.
+    """
+    queue: asyncio.Queue = asyncio.Queue()
+
+    async def _pump():
+        try:
+            async for event in agen:
+                await queue.put(event)
+                # Yield so the SSE consumer can dequeue and flush this event
+                # to the HTTP response before the next one is enqueued.
+                await asyncio.sleep(0)
+        except asyncio.CancelledError:
+            await queue.put({"type": "orchestration_error", "error": "Cancelled"})
+        except FileNotFoundError:
+            await queue.put({"type": "orchestration_error", "error": "Run not found"})
+        except Exception as e:
+            await queue.put({"type": "orchestration_error", "error": str(e)})
+        finally:
+            _active_tasks.pop(run_id, None)
+            print(f"DEBUG SSE QUEUE: sentinel sent for '{run_id}', stream closing", flush=True)
+            await queue.put(SENTINEL)
+
+    task = asyncio.create_task(_pump())
+    _active_tasks[run_id] = task
+    return task, queue
+
+
+async def stream_engine_events(agen, run_id: str) -> AsyncGenerator[dict, None]:
+    """Yield the engine's event dicts while a dedicated task advances it.
+
+    Deliberately does NOT cancel that task on close: the run is detached, so
+    abandoning this generator (client disconnect, GC finalization) must leave
+    it running -- the run still checkpoints and stays cancellable and
+    resumable.
+    """
+    _task, queue = spawn_engine_run(agen, run_id)
+    while True:
+        event = await queue.get()
+        if event is SENTINEL:
+            return
+        yield event

package/backend/core/orchestration/state.py

@@ -41,7 +41,11 @@ class SharedState:
         # Atomic write: write to temp, then rename
         fd, tmp_path = tempfile.mkstemp(dir=RUNS_DIR, suffix=".tmp")
         try:
-            with os.fdopen(fd, "w") as f:
+            # encoding="utf-8" is required: model_dump_json emits raw non-ASCII
+            # characters, and without an explicit encoding os.fdopen uses the
+            # platform default (cp1252 on Windows), which raises
+            # UnicodeEncodeError when a run's state contains non-ASCII text.
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
                 f.write(self.run.model_dump_json(indent=2))
             os.replace(tmp_path, target)
         except Exception:
@@ -55,7 +59,7 @@ class SharedState:
         path = RUNS_DIR / f"{run_id}.json"
         if not path.exists():
             raise FileNotFoundError(f"No checkpoint found for run {run_id}")
-        data = json.loads(path.read_text())
+        data = json.loads(path.read_text(encoding="utf-8"))
         run = OrchestrationRun.model_validate(data)
         return cls(run)
 
@@ -66,7 +70,7 @@ class SharedState:
         runs = []
         for f in sorted(RUNS_DIR.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)[:limit]:
             try:
-                data = json.loads(f.read_text())
+                data = json.loads(f.read_text(encoding="utf-8"))
                 runs.append({
                     "run_id": data.get("run_id"),
                     "orchestration_id": data.get("orchestration_id"),

package/backend/core/orchestration/steps.py

@@ -493,7 +493,7 @@ class ToolStepExecutor:
         tmp_dir = tempfile.mkdtemp(prefix="pytool_")
         script_path = f"{tmp_dir}/script.py"
         try:
-            with open(script_path, "w") as f:
+            with open(script_path, "w", encoding="utf-8") as f:
                 f.write(injected_code)
 
             docker_cmd = [
@@ -1161,7 +1161,7 @@ class TransformStepExecutor:
         tmp_dir = tempfile.mkdtemp(prefix="transform_host_")
         script_path = str(Path(tmp_dir) / "transform.py")
         try:
-            with open(script_path, "w") as f:
+            with open(script_path, "w", encoding="utf-8") as f:
                 f.write(script_content)
 
             proc = await asyncio.create_subprocess_exec(
@@ -1210,7 +1210,7 @@ class TransformStepExecutor:
         tmp_dir = tempfile.mkdtemp(prefix="transform_")
         script_path = f"{tmp_dir}/transform.py"
         try:
-            with open(script_path, "w") as f:
+            with open(script_path, "w", encoding="utf-8") as f:
                 f.write(script_content)
 
             docker_cmd = [

package/backend/core/personal_details.py

@@ -29,7 +29,7 @@ def load_personal_details() -> dict:
         return defaults
 
     try:
-        with open(PERSONAL_DETAILS_FILE, "r") as f:
+        with open(PERSONAL_DETAILS_FILE, "r", encoding="utf-8") as f:
             data = json.load(f)
 
         # Merge root
@@ -54,7 +54,7 @@ def save_personal_details(details: dict) -> dict:
     addr = d.get("address") if isinstance(d.get("address"), dict) else {}
     normalized["address"] = {**defaults["address"], **addr}
 
-    with open(PERSONAL_DETAILS_FILE, "w") as f:
+    with open(PERSONAL_DETAILS_FILE, "w", encoding="utf-8") as f:
         json.dump(normalized, f, indent=4)
 
     return normalized

package/backend/core/react_engine.py

@@ -4,6 +4,7 @@ Yields structured event dicts that callers can handle differently
 (collect for sync response, or stream as SSE).
 """
 import asyncio
+import contextlib
 import json
 import sys
 import time
@@ -47,50 +48,74 @@ MAX_TURNS = 30
 # Heartbeats are yielded as the raw SSE string, so endpoints can pass them
 # straight through; real events remain dicts (`isinstance(item, str)`
 # distinguishes them).
+#
+# The source is advanced by a single dedicated pump task rather than a fresh
+# task per pull. anyio binds a cancel scope to the task that entered it, so a
+# source holding a scope across a yield (the orchestration engine's per-step
+# timeout) must be advanced — and closed — from one task. See issue #356.
 # ──────────────────────────────────────────────────────────────────────────────
 SSE_HEARTBEAT = ": ping\n\n"
 
 
+class _StreamEnd:
+    """Sentinel handing the source's terminal state back to the consumer."""
+    __slots__ = ("error",)
+
+    def __init__(self, error):
+        self.error = error
+
+
 async def iter_with_heartbeat(agen, interval: float = 10.0):
     """Yield items from `agen`, injecting `SSE_HEARTBEAT` whenever no item
     arrives within `interval` seconds.
 
     The underlying generator is never cancelled on a heartbeat timeout — only
     when the consumer stops early (e.g. a client disconnect closes this
-    generator), in which case the pending pull is cancelled and the source is
-    closed in the finally block.
+    generator), in which case the pump is cancelled and closes the source.
     """
-    ait = agen.__aiter__()
-    pending = None
+    queue: asyncio.Queue = asyncio.Queue(maxsize=1)  # maxsize=1 keeps backpressure
+
+    async def _pump():
+        # Advances `agen` in THIS single task, so a cancel scope the source
+        # holds across a yield is never exited from another task — and
+        # aclose() below runs in that scope's host task too.
+        try:
+            async for item in agen:
+                await queue.put(item)
+            await queue.put(_StreamEnd(None))
+        except asyncio.CancelledError:
+            raise
+        except BaseException as exc:
+            with contextlib.suppress(BaseException):
+                await queue.put(_StreamEnd(exc))
+        finally:
+            aclose = getattr(agen, "aclose", None)
+            if aclose is not None:
+                with contextlib.suppress(BaseException):
+                    await aclose()
+
+    pump = asyncio.ensure_future(_pump())
     try:
         while True:
-            if pending is None:
-                pending = asyncio.ensure_future(ait.__anext__())
-            done, _ = await asyncio.wait({pending}, timeout=interval)
-            if not done:
+            try:
+                item = await asyncio.wait_for(queue.get(), timeout=interval)
+            except asyncio.TimeoutError:
+                if pump.done():
+                    # Source ended without a sentinel — it was cancelled.
+                    return
                 # No event within the interval — keep the stream warm.
                 yield SSE_HEARTBEAT
                 continue
-            task = pending
-            pending = None
-            try:
-                item = task.result()
-            except StopAsyncIteration:
+            if isinstance(item, _StreamEnd):
+                if item.error is not None:
+                    raise item.error
                 return
             yield item
     finally:
-        if pending is not None:
-            pending.cancel()
-            try:
-                await pending
-            except BaseException:
-                pass
-        aclose = getattr(agen, "aclose", None)
-        if aclose is not None:
-            try:
-                await aclose()
-            except BaseException:
-                pass
+        if not pump.done():
+            pump.cancel()
+        with contextlib.suppress(BaseException):
+            await pump
 
 
 async def drain_queue_with_heartbeat(queue, sentinel, interval: float = 10.0):
@@ -1208,7 +1233,7 @@ async def run_agent_step(
                                 tmp_dir = _tempfile.mkdtemp(prefix="pytool_")
                                 script_path = f"{tmp_dir}/script.py"
                                 try:
-                                    with open(script_path, "w") as _f:
+                                    with open(script_path, "w", encoding="utf-8") as _f:
                                         _f.write(injected_code)
 
                                     docker_cmd = [
@@ -1591,6 +1616,7 @@ async def run_react_loop(request, server_module):
                 from core.routes.orchestrations import load_orchestrations
                 from core.models_orchestration import Orchestration
                 from core.orchestration.engine import OrchestrationEngine
+                from core.orchestration.runner import stream_engine_events
 
                 orchs = load_orchestrations()
                 orch_data = next((o for o in orchs if o["id"] == orch_id), None)
@@ -1598,7 +1624,14 @@ async def run_react_loop(request, server_module):
                     orch = Orchestration.model_validate(orch_data)
                     engine = OrchestrationEngine(orch, server_module)
                     run_id = f"run_{orch_id}_{int(time.time() * 1000)}"
-                    async for event in engine.run(user_message, run_id, session_id=session_id):
+                    # Route through the shared runner, exactly as the editor's
+                    # run endpoint does: the engine holds anyio cancel scopes
+                    # across yields, so it must be advanced from a single task
+                    # no matter how the SSE layer consumes us (issue #356).
+                    # It also registers the run for cancel/reconnect.
+                    async for event in stream_engine_events(
+                        engine.run(user_message, run_id, session_id=session_id), run_id
+                    ):
                         yield event
                     return
                 else:

package/backend/core/routes/api_v1.py

@@ -113,8 +113,9 @@ async def v1_chat(body: V1ChatRequest, key_record: dict = Depends(require_api_ke
             etype = event.get("type", "")
             if etype == "final":
                 final_event = event
-            elif etype == "error":
-                error_msg = event.get("message", "Unknown error")
+            elif etype in ("error", "orchestration_error"):
+                # orchestration_error is what an orchestrator agent fails with.
+                error_msg = event.get("message") or event.get("error") or "Unknown error"
     except Exception as exc:
         log.exception("[v1/chat] Unhandled error for session=%s", chat_request.session_id)
         raise HTTPException(status_code=500, detail="An internal error occurred. Check server logs for details.")
@@ -204,8 +205,10 @@ async def v1_chat_stream(body: V1ChatRequest, key_record: dict = Depends(require
                     })
                     yield _format_sse_event({"type": "done"})
 
-                elif etype == "error":
-                    log.error("[v1/chat/stream] Agent error session=%s: %s", chat_request.session_id, event.get("message"))
+                elif etype in ("error", "orchestration_error"):
+                    # orchestration_error is what an orchestrator agent fails with.
+                    log.error("[v1/chat/stream] Agent error session=%s: %s", chat_request.session_id,
+                              event.get("message") or event.get("error"))
                     yield _format_sse_event({"type": "error", "message": "The agent encountered an error processing your request."})
 
                 await asyncio.sleep(0)
@@ -314,8 +317,11 @@ async def v1_orchestration_run_stream(
 
     async def event_stream():
         from core.react_engine import iter_with_heartbeat
+        from core.orchestration.runner import stream_engine_events
         try:
-            async for event in iter_with_heartbeat(engine.run(body.message, run_id)):
+            async for event in iter_with_heartbeat(
+                stream_engine_events(engine.run(body.message, run_id), run_id)
+            ):
                 # Heartbeat comments are yielded as raw SSE strings — pass through.
                 if isinstance(event, str):
                     yield event
@@ -436,8 +442,13 @@ async def v1_orchestration_resume_stream(
 
     async def event_stream():
         from core.react_engine import iter_with_heartbeat
+        from core.orchestration.runner import stream_engine_events
         try:
-            async for event in iter_with_heartbeat(OrchestrationEngine.resume(run_id, human_response, _server)):
+            async for event in iter_with_heartbeat(
+                stream_engine_events(
+                    OrchestrationEngine.resume(run_id, human_response, _server), run_id
+                )
+            ):
                 # Heartbeat comments are yielded as raw SSE strings — pass through.
                 if isinstance(event, str):
                     yield event

package/backend/core/routes/chat.py

@@ -39,6 +39,9 @@ async def chat(request: ChatRequest):
             final_event = event
         elif event["type"] == "error":
             return ChatResponse(response=event["message"], intent="chat", data=None, tool_name=None)
+        elif event["type"] == "orchestration_error":
+            # An orchestrator agent failed — same outcome, different event shape.
+            return ChatResponse(response=event["error"], intent="chat", data=None, tool_name=None)
 
     if not final_event:
         return ChatResponse(response="I completed the requested actions.", intent="chat", data=None, tool_name=None)

package/backend/core/routes/data.py

@@ -120,7 +120,7 @@ async def _get_github_token() -> "str | None":
         hosts_path = config_dir / "hosts.json"
         if hosts_path.exists():
             try:
-                data = _json.loads(hosts_path.read_text())
+                data = _json.loads(hosts_path.read_text(encoding="utf-8"))
                 t = (data.get("github.com", {}).get("oauth_token")
                      or data.get("github.com", {}).get("token"))
                 if t:
@@ -131,7 +131,7 @@ async def _get_github_token() -> "str | None":
     config_path = Path.home() / ".copilot" / "config.json"
     if config_path.exists():
         try:
-            data = _json.loads(config_path.read_text())
+            data = _json.loads(config_path.read_text(encoding="utf-8"))
             if t := (data.get("oauth_token") or data.get("token")):
                 return t
         except Exception:
@@ -839,7 +839,7 @@ async def clear_memory_items(req: MemoryClearRequest):
         repos = []
         if os.path.exists(repos_path):
             try:
-                with open(repos_path) as f:
+                with open(repos_path, encoding="utf-8") as f:
                     repos = json.load(f)
             except Exception:
                 pass
@@ -849,7 +849,7 @@ async def clear_memory_items(req: MemoryClearRequest):
                 drop_index(repo["id"])
             except Exception as e:
                 print(f"Error dropping index for repo {repo.get('id')}: {e}")
-        with open(repos_path, "w") as f:
+        with open(repos_path, "w", encoding="utf-8") as f:
             json.dump([], f)
         results["repos"] = f"Cleared {len(repos)} repo(s)"
 
@@ -859,11 +859,11 @@ async def clear_memory_items(req: MemoryClearRequest):
         configs = []
         if os.path.exists(configs_path):
             try:
-                with open(configs_path) as f:
+                with open(configs_path, encoding="utf-8") as f:
                     configs = json.load(f)
             except Exception:
                 pass
-        with open(configs_path, "w") as f:
+        with open(configs_path, "w", encoding="utf-8") as f:
             json.dump([], f)
         results["db_configs"] = f"Cleared {len(configs)} config(s)"
 

package/backend/core/routes/import_export.py

@@ -48,7 +48,7 @@ def _load_mcp_servers() -> List[dict]:
     if not os.path.exists(MCP_SERVERS_FILE):
         return []
     try:
-        with open(MCP_SERVERS_FILE) as f:
+        with open(MCP_SERVERS_FILE, encoding="utf-8") as f:
             return json.load(f)
     except Exception:
         return []
@@ -253,7 +253,7 @@ async def import_bundle(req: ImportRequest):
 
     if mcp_changed:
         os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
-        with open(MCP_SERVERS_FILE, "w") as f:
+        with open(MCP_SERVERS_FILE, "w", encoding="utf-8") as f:
             json.dump(existing_mcp, f, indent=4)
 
     # Always sync manager with authoritative disk state and attempt connections