@agentsdock/server 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsdock/server",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "AgentsDock's self-hosted Python server and explicit installation CLI",
   "license": "Apache-2.0",
   "repository": {

package/server/VERSION

@@ -1 +1 @@
-1.0.8
+1.0.9

package/server/agent_server.py

@@ -83265,7 +83265,20 @@ def public_chat_share_session_exists(session_id: str) -> bool:
     )
 
 
-async def create_native_side_chat(session_id: str, *, persisted_state=None, persist_state=None, durable=False):
+def side_chat_runtime_settings(session_id: str):
+    session = STORE.sessions.get(session_id)
+    if not session or str(session.get("backend") or DEFAULT_BACKEND).lower() != BACKEND_CODEX:
+        return {}
+    try:
+        model, effort, _service_tier = codex_runtime_settings(session)
+    except HTTPException:
+        # Optional settings do not gate reading retained side-chat history.
+        return {}
+    return {"model": model, "effort": effort}
+
+
+async def create_native_side_chat(session_id: str, *, persisted_state=None, persist_state=None, durable=False,
+                                  initial_runtime_settings=None):
     """Bind a side conversation to the provider's actual parent.
 
     No visible-message projection, main turn, queue or goal mutation belongs
@@ -83296,6 +83309,15 @@ async def create_native_side_chat(session_id: str, *, persisted_state=None, pers
     class NativeSideChat:
         codex = None
 
+        def __init__(self):
+            self.runtime_settings = dict((persisted_state or {}).get("runtime_settings") or initial_runtime_settings or {})
+            self.codex_state = (persisted_state or {}).get("codex")
+
+        async def save_state(self):
+            if persist_state is not None:
+                await persist_state({**binding, **({"runtime_settings": self.runtime_settings} if self.runtime_settings else {}),
+                                     **({"codex": self.codex_state} if self.codex_state else {})})
+
         def current(self):
             if SERVER_SHUTTING_DOWN:
                 raise side_questions.SideQuestionError(503, "Server is shutting down")
@@ -83313,9 +83335,12 @@ async def create_native_side_chat(session_id: str, *, persisted_state=None, pers
                 CODEX_PROVIDER_STORE.require_thread(parent_id, selected)
             return current
 
-        async def ask(self, question, *, history):
+        async def ask(self, question, *, history, runtime_settings=None, on_progress=None):
             current = self.current()
+            requested = side_questions.validate_runtime_settings(runtime_settings or {})
             if backend == BACKEND_CLAUDE:
+                if requested:
+                    raise side_questions.SideQuestionError(400, "Claude native side questions use the main conversation settings")
                 from claude_sdk_client import (ClaudeSDKGenerationChanged, ClaudeSDKConfigurationConflict,
                     ClaudeSDKRunActive, ClaudeSDKSupervisorError)
                 try:
@@ -83333,9 +83358,24 @@ async def create_native_side_chat(session_id: str, *, persisted_state=None, pers
                     raise side_questions.SideQuestionError(503, "Claude native side questions are unavailable; retry after reconnecting") from None
             else:
                 from codex_side_question import NativeCodexSideChat
+                # A side conversation owns its settings after first use. Only
+                # explicit side choices change them; never update the parent.
+                side_session = {**current, **self.runtime_settings, **requested}
+                model, effort, service_tier = codex_runtime_settings(side_session)
+                provider_selection = CODEX_PROVIDER_STORE.for_session(side_session, include_key=True)
+                summary = None
+                if provider_selection:
+                    model = provider_selection["model"]
+                    effort = codex_provider.runtime_effort(provider_selection,
+                        CODEX_PROVIDER_STORE.cached_catalog(provider_selection), side_session.get("effort"))
+                    summary = codex_provider.runtime_summary(provider_selection,
+                        CODEX_PROVIDER_STORE.cached_catalog(provider_selection))
+                    provider_selection["effort"] = effort
+                    provider_selection["reasoning_summary"] = summary
+                self.runtime_settings = {"model": model, "effort": effort}
+                await self.save_state()
                 if self.codex is None:
                     cwd = existing_cwd(str(current.get("cwd") or DEFAULT_CWD))
-                    model, effort, service_tier = codex_runtime_settings(current)
                     approval_policy = current.get("codex_approval_policy")
                     if approval_policy not in CODEX_APPROVAL_POLICIES:
                         approval_policy = CODEX_DEFAULT_APPROVAL_POLICY
@@ -83383,28 +83423,25 @@ async def create_native_side_chat(session_id: str, *, persisted_state=None, pers
                             side_session_id=session_id, side_owner_is_current=is_current,
                             side_approval_policy=approval_policy)
 
-                    provider_selection = CODEX_PROVIDER_STORE.for_session(current, include_key=True)
-                    if provider_selection:
-                        provider_selection["effort"] = codex_provider.runtime_effort(
-                            provider_selection, CODEX_PROVIDER_STORE.cached_catalog(provider_selection), current.get("effort"),
-                        )
-                        provider_selection["reasoning_summary"] = codex_provider.runtime_summary(
-                            provider_selection, CODEX_PROVIDER_STORE.cached_catalog(provider_selection))
                     async def save_codex_state(value):
-                        if persist_state is not None:
-                            await persist_state({**binding, "codex": value})
+                        self.codex_state = value
+                        await self.save_state()
                     self.codex = NativeCodexSideChat(parent_id, executable=CODEX_BIN,
                         model=model if isinstance(model, str) and model.strip() else None,
                         cwd=cwd, fork_overrides=fork_overrides, turn_overrides=turn_overrides,
                         server_request_handler=side_server_request,
                         env=side_questions.isolated_environment(runner_env()),
                         provider_selection=provider_selection, durable=durable,
-                        resume_state=(persisted_state or {}).get("codex"), persist_state=save_codex_state)
-                result = {"answer": await self.codex.ask(question),
+                        resume_state=self.codex_state, persist_state=save_codex_state)
+                result = {**self.runtime_settings, "answer": await self.codex.ask(question, on_progress=on_progress,
+                              runtime_settings={**self.runtime_settings, **({"reasoning_summary": summary} if summary else {})}),
                           "context_note": "Native Codex context from when Side chat started, including tool results. Clear Side chat to use the latest main context."}
             self.current()
             return {"backend": backend, **result}
 
+        def snapshot_progress(self, task):
+            return self.codex.snapshot_progress(task) if self.codex is not None else None
+
         async def close(self):
             if self.codex is not None:
                 await self.codex.close()
@@ -83423,7 +83460,7 @@ def require_side_question_admission():
 
 SIDE_QUESTIONS = side_questions.SideQuestions(native_factory=create_native_side_chat,
     storage_path=STATE_DIR / "side_chats.sqlite3", notify=lambda session_id, event: HUB.broadcast(session_id, event),
-    admission_check=require_side_question_admission)
+    admission_check=require_side_question_admission, runtime_settings_for_session=side_chat_runtime_settings)
 app.include_router(side_questions.create_side_question_router(
     authorize=require_native_admin_control,
     session_exists=public_chat_share_session_exists,

package/server/codex_side_chat_progress.py

@@ -0,0 +1,110 @@
+"""User-visible native Codex side-thread activity; never project parent/control input."""
+from __future__ import annotations
+
+import asyncio
+from copy import deepcopy
+
+
+class CodexSideChatProgress:
+    def __init__(self, publish, *, thread_id):
+        self.publish = publish
+        self.thread_id = thread_id
+        self.items = {}
+        self.parts = {}
+        self.completed = set()
+        self.pending = None
+        self.dirty = False
+
+    def _item(self, identifier, kind):
+        key = f"{identifier}:{kind}"
+        if key not in self.items:
+            self.items[key] = {"id": key, "kind": kind, "text": "", "status": "running"}
+        return self.items[key]
+
+    @staticmethod
+    def _text(parts):
+        if not isinstance(parts, list):
+            return ""
+        return "\n\n".join(part if isinstance(part, str) else str(part.get("text") or part.get("summary_text") or "")
+                            for part in parts if isinstance(part, (str, dict)))
+
+    def receive(self, packet):
+        method, data = packet.get("method"), packet.get("params") or {}
+        # The transport normally scopes notifications; enforce it here too so
+        # descendant activity cannot become the side assistant's own answer.
+        if data.get("threadId") not in (None, self.thread_id):
+            return
+        item = data.get("item") or {}
+        identifier = str(data.get("itemId") or item.get("id") or "")
+        if not identifier or identifier in self.completed:
+            return
+        changed = False
+        if method in {"item/reasoning/summaryTextDelta", "item/reasoning/textDelta", "item/reasoning/summaryPartAdded"}:
+            kind = "reasoning" if method == "item/reasoning/textDelta" else "reasoning_summary"
+            field = "contentIndex" if kind == "reasoning" else "summaryIndex"
+            index = data.get(field, 0)
+            if not isinstance(index, int) or index < 0:
+                return
+            parts = self.parts.setdefault((identifier, kind), {})
+            parts[index] = parts.get(index, "") + str(data.get("delta") or "")
+            self._item(identifier, kind)["text"] = "\n\n".join(parts[i] for i in sorted(parts))
+            changed = True
+        elif method == "item/agentMessage/delta":
+            # item/started carries the phase. Older runtimes may emit deltas
+            # first; item/completed supplies the authoritative final phase.
+            kind = "commentary" if f"{identifier}:commentary" in self.items else "answer"
+            self._item(identifier, kind)["text"] += str(data.get("delta") or "")
+            changed = True
+        elif method in {"item/started", "item/completed"}:
+            item_type = item.get("type")
+            if item_type == "reasoning":
+                for kind, field in (("reasoning_summary", "summary"), ("reasoning", "content")):
+                    text = self._text(item.get(field))
+                    if text or (identifier, kind) in self.parts:
+                        projected = self._item(identifier, kind)
+                        if text:
+                            projected["text"] = text
+                        changed = True
+            elif item_type == "agentMessage":
+                kind = "commentary" if item.get("phase") == "commentary" else "answer"
+                other = f"{identifier}:{'answer' if kind == 'commentary' else 'commentary'}"
+                if other in self.items:
+                    # Keep its chronological slot when an older runtime omits phase at start.
+                    self.items = {f"{identifier}:{kind}" if key == other else key:
+                                  {**value, "id": f"{identifier}:{kind}", "kind": kind} if key == other else value
+                                  for key, value in self.items.items()}
+                projected = self._item(identifier, kind)
+                if isinstance(item.get("text"), str) and (item["text"] or method == "item/completed"):
+                    projected["text"] = item["text"]
+                changed = True
+            elif item_type in {"commandExecution", "mcpToolCall", "dynamicToolCall", "collabAgentToolCall",
+                               "collabToolCall", "webSearch", "fileChange", "imageView", "imageGeneration"}:
+                projected = self._item(identifier, "tool")
+                projected["tool"] = item_type
+                text = item.get("command") if item_type == "commandExecution" else item.get("tool") or item.get("query") or item.get("path")
+                if not text and item_type == "fileChange":
+                    text = ", ".join(str(change.get("path") or "") for change in item.get("changes", []) if isinstance(change, dict))
+                if text:
+                    projected["text"] = str(text)
+                changed = True
+            if method == "item/completed":
+                self.completed.add(identifier)
+                for key, value in self.items.items():
+                    if key.startswith(identifier + ":"):
+                        value["status"] = "completed"
+        if changed:
+            self.dirty = True
+            if self.pending is None:
+                self.pending = asyncio.create_task(self._publish_later())
+
+    async def _publish_later(self):
+        # Coalesce token bursts; no per-token disk writes or client history reads.
+        await asyncio.sleep(0.1)
+        while self.dirty:
+            self.dirty = False
+            await self.publish(deepcopy(list(self.items.values())))
+        self.pending = None
+
+    async def flush(self):
+        if self.pending is not None:
+            await asyncio.shield(self.pending)

package/server/codex_side_question.py

@@ -179,6 +179,7 @@ class NativeCodexSideChat:
         self._cleaning: asyncio.Task | None = None
         self._process_started = asyncio.Event()
         self._active: asyncio.Task | None = None
+        self._progress = None
         self._lock = asyncio.Lock()
         self._closed = False
 
@@ -186,6 +187,12 @@ class NativeCodexSideChat:
     def closed(self) -> bool:
         return self._closed
 
+    def snapshot_progress(self, task):
+        """Copy exposed native items at Stop without flushing or awaiting IO."""
+        if task is None or task.done() or self._active is not task or self._progress is None:
+            return None
+        return deepcopy(list(self._progress.items.values()))
+
     async def _handle_server_request(self, request_id, method, params):
         # The callback can present approvals through the existing UI, but only
         # for this exact child. Never route a parent's inherited tool request.
@@ -284,7 +291,7 @@ class NativeCodexSideChat:
         elif metadata.get("ephemeral") is not True or metadata.get("path") is not None:
             raise SideQuestionError(503, "Codex did not confirm an ephemeral side chat")
 
-    async def ask(self, question: str) -> str:
+    async def ask(self, question: str, *, runtime_settings: dict | None = None, on_progress=None) -> str:
         if self._closed:
             raise SideQuestionError(409, "Side chat was closed; open a new side chat")
         if self._lock.locked():
@@ -292,6 +299,7 @@ class NativeCodexSideChat:
         async with self._lock:
             self._active = asyncio.current_task()
             turn = None
+            progress = None
             try:
                 if self._opening is None:
                     self._opening = asyncio.create_task(self._open())
@@ -300,14 +308,37 @@ class NativeCodexSideChat:
                 await asyncio.shield(self._opening)
                 if self._closed:
                     raise SideQuestionError(409, "Side chat was closed; open a new side chat")
+                overrides = {**self.turn_overrides, **self.provider_turn_overrides}
+                if runtime_settings is not None:
+                    model = runtime_settings["model"]
+                    effort = runtime_settings.get("effort") or ""
+                    # Explicit default must clear a previous turn's effort;
+                    # null effort alone would inherit it from the thread.
+                    overrides.pop("effort", None)
+                    overrides.update({"model": model, "collaborationMode": {"mode": "default", "settings": {
+                        "model": model, "reasoning_effort": effort or None, "developer_instructions": None}}})
+                    if effort:
+                        overrides["effort"] = effort
+                    if self.provider_config:
+                        from codex_provider import turn_overrides
+                        overrides.update(turn_overrides(model, effort,
+                            summary=runtime_settings.get("reasoning_summary") or "none"))
                 turn = await self._client.start_turn(
                     self.thread_id, [{"type": "text", "text": question}],
-                    overrides={**self.turn_overrides, **self.provider_turn_overrides},
+                    overrides=overrides,
                 )
+                if on_progress is not None:
+                    from codex_side_chat_progress import CodexSideChatProgress
+                    progress = CodexSideChatProgress(on_progress, thread_id=self.thread_id)
+                    self._progress = progress
                 answers: dict[str, str] = {}
                 while True:
                     packet = await turn.next_notification()
                     method, data = packet.get("method"), packet.get("params", {})
+                    if data.get("threadId") not in (None, self.thread_id):
+                        continue
+                    if progress is not None:
+                        progress.receive(packet)
                     if method == "item/completed":
                         item = data.get("item", {})
                         if item.get("type") == "agentMessage" and item.get("phase") in (None, "", "final_answer"):
@@ -323,6 +354,8 @@ class NativeCodexSideChat:
                         answer = "\n\n".join(answers.values()).strip()
                         if not answer:
                             raise SideQuestionError(502, "Codex did not return a side question answer")
+                        if progress is not None:
+                            await progress.flush()
                         return answer
             except CodexAppServerError:
                 await self.close()
@@ -331,9 +364,16 @@ class NativeCodexSideChat:
                 await self.close()
                 raise
             finally:
-                if turn is not None:
-                    await turn.close()
-                self._active = None
+                try:
+                    if progress is not None:
+                        await progress.flush()
+                finally:
+                    try:
+                        if turn is not None:
+                            await turn.close()
+                    finally:
+                        self._progress = None
+                        self._active = None
 
     async def close(self):
         self._closed = True

package/server/install.sh

@@ -1839,7 +1839,7 @@ if [[ "$TEAM_HUB_MODE" == "host" && "$TEAM_HUB_OPERATION_PENDING" != "true" \
   fi
 fi
 
-RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py cursor_process_guard.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
+RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py codex_side_chat_progress.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py cursor_process_guard.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
 RELEASE_DIRECTORIES=(agentsdock_team_hub)
 TEAM_HUB_RELEASE_FILES=(
   __init__.py
@@ -3055,21 +3055,37 @@ install_lock_control() {
   local action="$1"
   local expected_device="${2:-0}"
   local expected_inode="${3:-0}"
+  local wait_for_prepared="false"
+  # Old managed preparers do not pass a managed-update ID. The existing pinned
+  # preparation/activation modes may serialize briefly; this grants no update
+  # authority and leaves ordinary installation and recovery fail-fast.
+  if [[ "$action" == "acquire" && "${RECOVER_ONLY:-false}" != "true" \
+    && "${RECOVER_UNARMED_ONLY:-false}" != "true" \
+    && ( "${PREPARE_ONLY:-false}" == "true" || -n "${ACTIVATE_PREPARED:-}" ) \
+    && "${PREPARED_ARCHIVE_SHA256:-}" =~ ^[0-9a-f]{64}$ \
+    && "${EXPECTED_API_CONTRACT:-}" =~ ^[1-9][0-9]*$ \
+    && -n "${RELEASE_VERSION:-}" ]]; then
+    wait_for_prepared="true"
+  fi
   local python_path=""
   python_path="$(install_lock_python)" || return 1
   "$python_path" - \
-    "$action" "$INSTALL_ROOT" "$$" "$expected_device" "$expected_inode" <<'PY'
+    "$action" "$INSTALL_ROOT" "$$" "$expected_device" "$expected_inode" "$wait_for_prepared" <<'PY'
 import errno
 import os
 from pathlib import Path
 import secrets
+import signal
 import stat
 import sys
+import time
 
-action, raw_root, raw_pid, raw_device, raw_inode = sys.argv[1:]
+action, raw_root, raw_pid, raw_device, raw_inode, raw_wait = sys.argv[1:]
 root = Path(os.path.abspath(raw_root))
 pid = int(raw_pid)
 lock = root / ".install-lock"
+PREPARED_LOCK_WAIT_SECONDS = 30.0
+wait_for_prepared = action == "acquire" and raw_wait == "true"
 
 root_info = root.lstat()
 if (
@@ -3145,7 +3161,56 @@ def read_owner(directory_descriptor: int) -> tuple[int, tuple[int, int]]:
     return int(value), (int(info.st_dev), int(info.st_ino))
 
 
+def check_wait_root() -> None:
+    current = root.lstat()
+    if ((current.st_dev, current.st_ino) != (root_info.st_dev, root_info.st_ino)
+            or not stat.S_ISDIR(current.st_mode) or current.st_uid != os.geteuid()
+            or stat.S_IMODE(current.st_mode) & 0o022):
+        raise PermissionError("AgentsServer install root changed while waiting")
+
+
+def same_wait_owner(directory_descriptor, directory_info, owner_pid, owner_identity) -> bool:
+    check_wait_root()
+    current = lock.lstat()
+    if ((current.st_dev, current.st_ino) != (directory_info.st_dev, directory_info.st_ino)):
+        return False
+    if (not stat.S_ISDIR(current.st_mode) or current.st_uid != os.geteuid()
+            or stat.S_IMODE(current.st_mode) & 0o077):
+        raise PermissionError("AgentsServer install lock directory is unsafe")
+    return read_owner(directory_descriptor) == (owner_pid, owner_identity)
+
+
+def cleanup_wait_candidate(path, expected) -> None:
+    # Cancellation while waiting may remove only our still-unpublished draft.
+    # An acquired-but-unreported lock is left for ordinary dead-owner reaping.
+    try:
+        check_wait_root()
+        descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_DIRECTORY)
+        try:
+            current = os.fstat(descriptor)
+            linked = path.lstat()
+            identity = (expected.st_dev, expected.st_ino)
+            if ((current.st_dev, current.st_ino) != identity
+                    or (linked.st_dev, linked.st_ino) != identity):
+                return
+            owner, owner_identity = read_owner(descriptor)
+            if owner != pid or read_owner(descriptor) != (owner, owner_identity):
+                return
+            os.unlink("pid", dir_fd=descriptor)
+            os.fsync(descriptor)
+            linked = path.lstat()
+            if (linked.st_dev, linked.st_ino) == identity:
+                path.rmdir()
+        finally:
+            os.close(descriptor)
+    except (OSError, RuntimeError):
+        pass  # Preserve the original cancellation/failure; never guess ownership.
+
+
 if action == "acquire":
+    # One budget includes owner/namespace changes. Waiting only observes an
+    # existing safe lock; all authority checks still follow atomic acquisition.
+    deadline = time.monotonic() + PREPARED_LOCK_WAIT_SECONDS
     candidate = root / f".install-lock.{pid}.{secrets.token_hex(12)}.tmp"
     os.mkdir(candidate, 0o700)
     os.chmod(candidate, 0o700)
@@ -3165,21 +3230,44 @@ if action == "acquire":
         finally:
             os.close(descriptor)
         fsync_directory(candidate)
-        for _attempt in range(32):
+        if wait_for_prepared:
+            def cancelled(signum, _frame):
+                raise SystemExit(128 + signum)
+            for signum in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP):
+                signal.signal(signum, cancelled)
+        namespace_attempts = 0
+        while namespace_attempts < 32:
+            if wait_for_prepared:
+                check_wait_root()
+                if time.monotonic() >= deadline:
+                    raise RuntimeError("AgentsServer prepared update timed out waiting for the installation lock")
             try:
                 os.rename(candidate, lock)
             except OSError as exc:
                 if exc.errno not in {errno.EEXIST, errno.ENOTEMPTY}:
                     raise
-                directory_descriptor, directory_info = open_lock_directory()
                 try:
+                    directory_descriptor, directory_info = open_lock_directory()
+                except FileNotFoundError:
+                    if not wait_for_prepared:
+                        raise
+                    # The incumbent retired after rename observed its lock.
+                    namespace_attempts += 1
+                    continue
+                try:
+                    if wait_for_prepared and any(
+                        name != "pid" for name in os.listdir(directory_descriptor)
+                    ):
+                        raise PermissionError("AgentsServer install lock contains unknown files")
                     try:
                         owner_pid, owner_identity = read_owner(directory_descriptor)
                     except FileNotFoundError:
                         # An old installer may have crashed in mkdir->pid. The
                         # next atomic directory rename replaces only that
                         # exact empty namespace; a populated replacement wins.
+                        namespace_attempts += 1
                         continue
+                    alive = False
                     try:
                         os.kill(owner_pid, 0)
                     except ProcessLookupError:
@@ -3189,6 +3277,22 @@ if action == "acquire":
                             f"another AgentsServer installation is active ({owner_pid})"
                         )
                     else:
+                        alive = True
+                    if alive:
+                        if wait_for_prepared:
+                            try:
+                                unchanged = same_wait_owner(directory_descriptor, directory_info,
+                                                            owner_pid, owner_identity)
+                            except FileNotFoundError:
+                                unchanged = False
+                            if not unchanged:
+                                namespace_attempts += 1
+                                continue
+                            remaining = deadline - time.monotonic()
+                            if remaining <= 0:
+                                raise RuntimeError("AgentsServer prepared update timed out waiting for the installation lock")
+                            time.sleep(min(0.1, remaining))
+                            continue
                         raise RuntimeError(
                             f"another AgentsServer installation is active ({owner_pid})"
                         )
@@ -3200,19 +3304,25 @@ if action == "acquire":
                             directory_descriptor
                         )
                     except FileNotFoundError:
+                        namespace_attempts += 1
                         continue
                     if current_owner != owner_pid or current_identity != owner_identity:
+                        namespace_attempts += 1
                         continue
                     try:
                         os.unlink("pid", dir_fd=directory_descriptor)
                     except FileNotFoundError:
+                        namespace_attempts += 1
                         continue
                     os.fsync(directory_descriptor)
                 finally:
                     os.close(directory_descriptor)
+                namespace_attempts += 1
                 continue
             else:
                 owned = True
+                if wait_for_prepared:
+                    check_wait_root()
                 for _ in range(3):
                     try:
                         fsync_directory(root)
@@ -3232,7 +3342,9 @@ if action == "acquire":
                 raise SystemExit(0)
         raise RuntimeError("AgentsServer install lock ownership kept changing")
     finally:
-        if not owned:
+        if not owned and wait_for_prepared:
+            cleanup_wait_candidate(candidate, candidate_info)
+        elif not owned:
             try:
                 (candidate / "pid").unlink()
             except FileNotFoundError:
@@ -3644,6 +3756,7 @@ validate_staged_release_runtime() (
     "$STAGE_DIR/side_questions.py" \
     "$STAGE_DIR/workspace_git.py" \
     "$STAGE_DIR/codex_side_question.py" \
+    "$STAGE_DIR/codex_side_chat_progress.py" \
     "$STAGE_DIR/title_generation.py" \
     "$STAGE_DIR/claude_side_question.py" \
     "$STAGE_DIR/cursor_agent_client.py" \
@@ -3668,7 +3781,7 @@ validate_staged_release_runtime() (
     "$STAGE_DIR/update_runner.py"
   "$STAGE_DIR/.venv/bin/python" -m py_compile "$STAGE_DIR/server_instances.py"
   "$STAGE_DIR/.venv/bin/python" -m compileall -q "$STAGE_DIR/agentsdock_team_hub"
-  PYTHONPATH="$STAGE_DIR" "$STAGE_DIR/.venv/bin/python" -c 'import execution_activation, execution_preparation, update_preparation, update_handoff, update_recovery, execution_update_status, execution_uninstall, execution_recovery, execution_recovery_status, execution_http, execution_durability, execution_control, execution_install, execution_maintenance, execution_manage, execution_ownership, execution_service, execution_transport; import workspace_git, claude_model_catalog, server_instances, local_session_ownership, cursor_history; import codex_auth, codex_provider, provider_connections, cursor_api_key, side_questions, title_generation, codex_side_question, claude_side_question, agentsdock_team_hub, cursor_agent_client, cursor_provider_mcp, opencode_agent_client, cursor_process_guard, secure_peer_delivery, secure_peer_runtime, team_mail_runtime, team_mail_websocket, team_mail_grants, team_hub_host, agentsdock_mail, agentsdock_team, claude_history_repair, claude_history_provenance, claude_goals, claude_background_reconciliation, codex_history_repair, public_chat_shares, public_chat_transcript, public_chat_share_routes, interactive_chat_shares, interactive_chat_share_routes, interactive_chat_share_web, interactive_chat_projection, interactive_chat_runtime, interactive_chat_native, shared_chat_videos, shared_chat_video_stream, interactive_chat_controls, chat_mailbox, provider_commands, provider_usage; from agentsdock_team_hub import secure_peer, secure_peer_hub' >/dev/null
+  PYTHONPATH="$STAGE_DIR" "$STAGE_DIR/.venv/bin/python" -c 'import execution_activation, execution_preparation, update_preparation, update_handoff, update_recovery, execution_update_status, execution_uninstall, execution_recovery, execution_recovery_status, execution_http, execution_durability, execution_control, execution_install, execution_maintenance, execution_manage, execution_ownership, execution_service, execution_transport; import workspace_git, claude_model_catalog, server_instances, local_session_ownership, cursor_history; import codex_auth, codex_provider, provider_connections, cursor_api_key, side_questions, title_generation, codex_side_question, codex_side_chat_progress, claude_side_question, agentsdock_team_hub, cursor_agent_client, cursor_provider_mcp, opencode_agent_client, cursor_process_guard, secure_peer_delivery, secure_peer_runtime, team_mail_runtime, team_mail_websocket, team_mail_grants, team_hub_host, agentsdock_mail, agentsdock_team, claude_history_repair, claude_history_provenance, claude_goals, claude_background_reconciliation, codex_history_repair, public_chat_shares, public_chat_transcript, public_chat_share_routes, interactive_chat_shares, interactive_chat_share_routes, interactive_chat_share_web, interactive_chat_projection, interactive_chat_runtime, interactive_chat_native, shared_chat_videos, shared_chat_video_stream, interactive_chat_controls, chat_mailbox, provider_commands, provider_usage; from agentsdock_team_hub import secure_peer, secure_peer_hub' >/dev/null
 )
 
 abort_unclaimed_team_hub_reactivation() {

package/server/side_questions.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress, closing
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 import hashlib
 import json
@@ -57,7 +57,36 @@ class SideQuestionError(Exception):
 
 def capability():
     return {"available": True, "version": 2, "native_context": True, "backends": ["codex", "claude"],
-            "max_question_chars": MAX_QUESTION_CHARS, "sync": True}
+            "max_question_chars": MAX_QUESTION_CHARS, "sync": True, "runtime_settings": True}
+
+
+def validate_runtime_settings(value):
+    """Only explicit per-turn choices; omission preserves the side runtime."""
+    result = {}
+    for key in ("model", "effort"):
+        if key not in value:
+            continue
+        setting = value[key]
+        if not isinstance(setting, str) or len(setting) > 256 or any(ord(c) < 32 for c in setting):
+            raise SideQuestionError(400, "Invalid side chat runtime setting")
+        try:
+            setting.encode("utf-8")
+        except UnicodeEncodeError:
+            raise SideQuestionError(400, "Invalid side chat runtime setting") from None
+        setting = setting.strip()
+        if key == "model" and not setting:
+            raise SideQuestionError(400, "Side chat model must not be empty")
+        if key == "effort" and setting not in {"", "none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"}:
+            raise SideQuestionError(400, "Invalid side chat reasoning effort")
+        result[key] = setting
+    return result
+
+
+def request_digest(question, runtime_settings=None):
+    # Retain old receipts exactly when the optional settings were absent.
+    payload = (json.dumps([question, runtime_settings], sort_keys=True, ensure_ascii=False)
+               if runtime_settings else question)
+    return hashlib.sha256(payload.encode()).hexdigest()
 
 
 def validate_history(value) -> tuple[tuple[str, str], ...]:
@@ -328,6 +357,7 @@ class _Receipt:
     waiters: int = 0
     side_chat_id: str | None = None
     after_request_id: str | None = None
+    runtime_settings: dict = field(default_factory=dict)
 
 
 @dataclass
@@ -345,14 +375,15 @@ NATIVE_IDLE_SECONDS = 30 * 60
 
 
 class SideQuestions:
-    def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None):
+    def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None, runtime_settings_for_session=None):
         self.answer = answer
         self.native_factory = native_factory
         self.admission_check = admission_check
         self.receipts: dict[tuple[str, str, str], _Receipt] = {}
         self.conversations: dict[tuple[str, str, str], _NativeConversation] = {}
         self.cleanup_tasks: set[asyncio.Task] = set()
-        self.synced = (SyncedSideChats(storage_path, native_factory=native_factory, notify=notify, admission_check=admission_check)
+        self.synced = (SyncedSideChats(storage_path, native_factory=native_factory, notify=notify, admission_check=admission_check,
+                                       runtime_settings_for_session=runtime_settings_for_session)
                        if storage_path is not None else None)
 
     def active_session_ids(self):
@@ -395,7 +426,7 @@ class SideQuestions:
                 task.exception()
         task.add_done_callback(finished)
 
-    async def _native_answer(self, owner, session_id, request_id, question, side_chat_id, after_request_id):
+    async def _native_answer(self, owner, session_id, request_id, question, side_chat_id, after_request_id, runtime_settings=None):
         key = (owner, session_id, side_chat_id)
         conversation = self.conversations.get(key)
         if conversation is None:
@@ -416,7 +447,8 @@ class SideQuestions:
                 conversation.handle = await self.native_factory(session_id)
             if conversation.closed:
                 raise SideQuestionError(410, "Side chat ended")
-            result = await conversation.handle.ask(question, history=list(conversation.history))
+            result = await conversation.handle.ask(question, history=list(conversation.history),
+                **({"runtime_settings": runtime_settings} if runtime_settings else {}))
             if conversation.closed:
                 raise SideQuestionError(410, "Side chat ended")
             # Claude /btw replays the last twenty side exchanges natively.
@@ -450,9 +482,10 @@ class SideQuestions:
                 self.receipts.pop(key, None)
 
     def submit(self, owner: str, session_id: str, request_id: str, question: str, *, history: list[dict] | None = None,
-               side_chat_id: str | None = None, after_request_id: str | None = None):
+               side_chat_id: str | None = None, after_request_id: str | None = None, runtime_settings=None):
         if self.admission_check is not None:
             self.admission_check()
+        runtime_settings = validate_runtime_settings(runtime_settings or {})
         frozen_history = validate_history([] if history is None else history)
         self._prune()
         key = (owner, session_id, request_id)
@@ -461,17 +494,19 @@ class SideQuestions:
             if receipt.cancelled:
                 raise SideQuestionError(409, "Side question was cancelled; submit with a new request ID")
             if (receipt.question != question or receipt.history != frozen_history
-                    or receipt.side_chat_id != side_chat_id or receipt.after_request_id != after_request_id):
+                    or receipt.side_chat_id != side_chat_id or receipt.after_request_id != after_request_id
+                    or receipt.runtime_settings != runtime_settings):
                 raise SideQuestionError(409, "Request ID already belongs to a different side question")
             return receipt
         if self.native_factory is not None and (not side_chat_id or frozen_history):
             raise SideQuestionError(409, "Update the app to use native Side chat; copied conversation history is no longer accepted.")
-        receipt = _Receipt(question, history=frozen_history, side_chat_id=side_chat_id, after_request_id=after_request_id)
+        receipt = _Receipt(question, history=frozen_history, side_chat_id=side_chat_id, after_request_id=after_request_id,
+                           runtime_settings=runtime_settings)
         self.receipts[key] = receipt
 
         async def run():
             try:
-                answer = (self._native_answer(owner, session_id, request_id, question, side_chat_id, after_request_id)
+                answer = (self._native_answer(owner, session_id, request_id, question, side_chat_id, after_request_id, runtime_settings)
                           if self.native_factory is not None else
                           self.answer(session_id, question, history=history_messages(frozen_history))
                           if frozen_history else self.answer(session_id, question))
@@ -603,7 +638,7 @@ class SideChatStore:
             if receipt is not None:
                 database.execute("INSERT INTO receipts VALUES(?,?,?,?,?)",
                                  (owner, session, receipt["request_id"], document["side_chat_id"],
-                                  hashlib.sha256(receipt["question"].encode()).hexdigest()))
+                                  request_digest(receipt["question"], receipt.get("runtime_settings"))))
             provider_state = document.get("_provider_state") or {}
             thread_id = (provider_state.get("codex") or {}).get("thread_id")
             if isinstance(thread_id, str) and thread_id:
@@ -658,7 +693,8 @@ class SyncedSideChats:
     after an app disconnect or an unexpected process exit.
     """
 
-    def __init__(self, path, *, native_factory, notify=None, admission_check=None):
+    def __init__(self, path, *, native_factory, notify=None, admission_check=None, runtime_settings_for_session=None):
+        self.runtime_settings_for_session = runtime_settings_for_session
         self.store = SideChatStore(path)
         self.native_factory = native_factory
         self.notify = notify
@@ -700,9 +736,21 @@ class SyncedSideChats:
 
     async def snapshot(self, owner, session):
         async with self._lock((owner, session)):
-            return self.public(self._load((owner, session)))
-
-    async def submit(self, owner, session, request_id, question, side_chat_id, after_request_id=None):
+            document = self._load((owner, session))
+            if "model" not in document and self.runtime_settings_for_session is not None:
+                # Retained history stays readable when provider credentials,
+                # endpoint configuration or model discovery are unavailable.
+                settings = {}
+                with suppress(Exception):
+                    settings = self.runtime_settings_for_session(session)
+                if settings:
+                    document.update(settings)
+                    document["revision"] += 1
+                    self.store.save(owner, session, document)
+            return self.public(document)
+
+    async def submit(self, owner, session, request_id, question, side_chat_id, after_request_id=None, runtime_settings=None):
+        runtime_settings = validate_runtime_settings(runtime_settings or {})
         key = (owner, session)
         async with self._lock(key):
             if self.stopping:
@@ -712,7 +760,7 @@ class SyncedSideChats:
             document = self._load(key)
             previous = self.store.receipt(*key, request_id)
             if previous is not None:
-                if previous != (side_chat_id, hashlib.sha256(question.encode()).hexdigest()) or document["side_chat_id"] != side_chat_id:
+                if previous != (side_chat_id, request_digest(question, runtime_settings)) or document["side_chat_id"] != side_chat_id:
                     raise SideQuestionError(409, "Request ID belongs to a different or cleared side chat")
                 return self.public(document)
             if document["side_chat_id"] != side_chat_id:
@@ -725,14 +773,15 @@ class SyncedSideChats:
             if document["last_request_id"] != after_request_id:
                 raise SideQuestionError(409, "Side chat changed; refresh before sending")
             exchange = {"request_id": request_id, "question": question, "status": "running",
-                        "created_at": side_chat_timestamp(), "updated_at": side_chat_timestamp()}
+                        "created_at": side_chat_timestamp(), "updated_at": side_chat_timestamp(),
+                        **({"runtime_settings": runtime_settings} if runtime_settings else {})}
             document["exchanges"].append(exchange)
             document["revision"] += 1
             self.store.save(*key, document, receipt=exchange)
             timer = self.timers.pop(key, None)
             if timer is not None:
                 timer.cancel()
-            task = asyncio.create_task(self._answer(key, side_chat_id, request_id, question), name="synced-side-question")
+            task = asyncio.create_task(self._answer(key, side_chat_id, request_id, question, runtime_settings), name="synced-side-question")
             self.tasks[key] = task
             def done(completed):
                 if self.tasks.get(key) is completed:
@@ -750,9 +799,33 @@ class SyncedSideChats:
             if document["side_chat_id"] != side_chat_id:
                 raise SideQuestionError(409, "Side chat was cleared")
             document["_provider_state"] = value
+            settings = value.get("runtime_settings") or {}
+            changed = any(document.get(name) != setting for name, setting in settings.items())
+            document.update(settings)
+            if changed:
+                document["revision"] += 1
             self.store.save(*key, document)
+        if changed:
+            await self._changed(document)
+
+    async def _progress(self, key, side_chat_id, request_id, activity):
+        async with self._lock(key):
+            document = self.pending_writes.get(key) or self._load(key)
+            if document["side_chat_id"] != side_chat_id:
+                return
+            exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
+            if exchange is None or exchange["status"] != "running":
+                return
+            exchange.update(activity=activity, updated_at=side_chat_timestamp())
+            document["revision"] += 1
+            try:
+                self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
+            except (OSError, sqlite3.Error):
+                self.pending_writes[key] = document
+        await self._changed(document)
 
-    async def _answer(self, key, side_chat_id, request_id, question):
+    async def _answer(self, key, side_chat_id, request_id, question, runtime_settings=None):
         handle = None
         failed = False
         try:
@@ -762,11 +835,15 @@ class SyncedSideChats:
             handle = self.handles.get(key)
             if handle is None:
                 handle = await self.native_factory(key[1], persisted_state=document.get("_provider_state"),
-                    persist_state=lambda value: self._provider_state(key, side_chat_id, value), durable=True)
+                    persist_state=lambda value: self._provider_state(key, side_chat_id, value), durable=True,
+                    **({"initial_runtime_settings": {name: document[name] for name in ("model", "effort") if name in document}}
+                       if "model" in document else {}))
                 self.handles[key] = handle
             history = [{"question": item["question"], "response": item["answer"]}
                        for item in document["exchanges"] if item["status"] == "completed"][-20:]
-            result = await handle.ask(question, history=history)
+            result = await handle.ask(question, history=history,
+                on_progress=lambda activity: self._progress(key, side_chat_id, request_id, activity),
+                **({"runtime_settings": runtime_settings} if runtime_settings else {}))
             await self._finish(key, side_chat_id, request_id, "completed", **result)
         except asyncio.CancelledError:
             failed = True
@@ -802,17 +879,19 @@ class SyncedSideChats:
 
     async def _finish(self, key, side_chat_id, request_id, status, **result):
         async with self._lock(key):
-            document = self._load(key)
+            document = self.pending_writes.get(key) or self._load(key)
             if document["side_chat_id"] != side_chat_id:
                 return
             exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
             if exchange is None or exchange["status"] != "running":
                 return
             exchange.update(status=status, updated_at=side_chat_timestamp(), **result)
+            document.update({key: result[key] for key in ("model", "effort") if key in result})
             document["last_request_id"] = request_id
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
         await self._changed(document)
@@ -830,7 +909,9 @@ class SyncedSideChats:
     async def cancel(self, owner, session, request_id):
         key = (owner, session)
         async with self._lock(key):
-            document = self._load(key)
+            # Pending progress may be unsaved while provider work is active.
+            # Storage recovery must not gate the operator's Stop intent.
+            document = self.pending_writes.get(key) or self._load(key)
             exchange = next((item for item in document["exchanges"] if item["request_id"] == request_id), None)
             if exchange is None:
                 # Stop can overtake submission in transit. Preserve an opaque
@@ -839,15 +920,24 @@ class SyncedSideChats:
                     self.store.save(*key, document, receipt={"request_id": request_id, "question": ""})
                 return self.public(document)
             if exchange["status"] != "running":
-                return self.public(document)
+                return self.public(self._load(key))
+            task = self.tasks.get(key)
+            snapshot_progress = getattr(self.handles.get(key), "snapshot_progress", None)
+            if task is not None and callable(snapshot_progress):
+                # Capture only native items received by this exact request
+                # before Stop. Later coalesced callbacks stay fenced below.
+                with suppress(Exception):
+                    activity = snapshot_progress(task)
+                    if activity is not None:
+                        exchange["activity"] = activity
             exchange.update(status="cancelled", updated_at=side_chat_timestamp())
             document["last_request_id"] = request_id
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
-            task = self.tasks.get(key)
             if task is not None:
                 task.cancel()
         if task is not None:
@@ -858,15 +948,20 @@ class SyncedSideChats:
     async def clear(self, owner, session, side_chat_id):
         key = (owner, session)
         async with self._lock(key):
-            document = self._load(key)
+            # Preserve the new conversation fence even if progress storage
+            # is unavailable; still retire the old provider immediately.
+            document = self.pending_writes.get(key) or self._load(key)
             if document["side_chat_id"] != side_chat_id:
                 # A repeated Clear is harmless. A stale device cannot clear a
                 # new conversation it has not seen.
-                return self.public(document)
+                return self.public(self._load(key))
             document.update(side_chat_id=uuid.uuid4().hex, exchanges=[], last_request_id=None, _provider_state=None)
+            document.pop("model", None)
+            document.pop("effort", None)
             document["revision"] += 1
             try:
                 self.store.save(*key, document)
+                self.pending_writes.pop(key, None)
             except (OSError, sqlite3.Error):
                 self.pending_writes[key] = document
             task = self.tasks.get(key)
@@ -947,7 +1042,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except asyncio.TimeoutError:
             raise HTTPException(408, "Side question request was not received") from None
         if (not isinstance(value, dict) or not {"request_id", "question"} <= set(value)
-                or set(value) - {"request_id", "question", "history", "side_chat_id", "after_request_id"}):
+                or set(value) - {"request_id", "question", "history", "side_chat_id", "after_request_id", "model", "effort"}):
             raise HTTPException(400, "Invalid side question fields")
         for field in ("side_chat_id", "after_request_id"):
             if field in value and (not isinstance(value[field], str) or not IDENTIFIER.fullmatch(value[field])):
@@ -977,7 +1072,8 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         receipt = None
         try:
             receipt = runtime.submit(owner, session_id, request_id, question, history=history,
-                                     side_chat_id=value.get("side_chat_id"), after_request_id=value.get("after_request_id"))
+                                     side_chat_id=value.get("side_chat_id"), after_request_id=value.get("after_request_id"),
+                                     runtime_settings=validate_runtime_settings(value))
             receipt.waiters += 1
             watcher = asyncio.create_task(disconnected())
             done, _ = await asyncio.wait({receipt.task, watcher}, return_when=asyncio.FIRST_COMPLETED)
@@ -1047,7 +1143,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except asyncio.TimeoutError:
             raise HTTPException(408, "Side question request was not received") from None
         if (not isinstance(value, dict) or not {"request_id", "question", "side_chat_id"} <= set(value)
-                or set(value) - {"request_id", "question", "side_chat_id", "after_request_id"}):
+                or set(value) - {"request_id", "question", "side_chat_id", "after_request_id", "model", "effort"}):
             raise HTTPException(400, "Invalid side question fields")
         for field in ("request_id", "side_chat_id", "after_request_id"):
             if field == "after_request_id" and value.get(field) is None:
@@ -1062,7 +1158,8 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         except UnicodeEncodeError:
             raise HTTPException(400, "Question must contain valid Unicode text") from None
         return await synced_response(synced_runtime().submit(owner, session_id, value["request_id"], question,
-            value["side_chat_id"], value.get("after_request_id")), status_code=202)
+            value["side_chat_id"], value.get("after_request_id"),
+            runtime_settings=value), status_code=202)
 
     @router.delete("/api/sessions/{session_id}/side-chat/requests/{request_id}")
     async def cancel_synced(session_id: str, request_id: str, request: Request):