fix(unity): wait for bridge readiness after recompile

Author: r1n7aro

src-tauri/src/unity_bridge/mod.rs

@@ -1347,6 +1347,56 @@ pub async fn unity_execute_code(project_path: &str, code: &str) -> Result<String
     unity_execute_code_with_progress(project_path, code, |_| {}).await
 }
 
+async fn wait_for_unity_bridge_ready_after_recompile(project_path: &str) -> Result<(), String> {
+    let max_wait = Duration::from_secs(30);
+    let start = std::time::Instant::now();
+
+    loop {
+        let detail =
+            match send_message_with_timeout(project_path, "status", "", Duration::from_secs(5))
+                .await
+            {
+                Ok(resp) if resp.ok => return Ok(()),
+                Ok(resp) => resp
+                    .error
+                    .unwrap_or_else(|| "Unity status returned ok=false".to_string()),
+                Err(error) => error,
+            };
+
+        if start.elapsed() > max_wait {
+            return Err(format!(
+                "Timed out waiting for Unity bridge to become ready after recompile (30s): {}",
+                detail
+            ));
+        }
+
+        tokio::time::sleep(Duration::from_millis(500)).await;
+    }
+}
+
+async fn refresh_unity_type_index_after_recompile(project_path: &str) -> Result<(), String> {
+    const MAX_ATTEMPTS: u32 = 3;
+    let mut last_error = String::new();
+
+    for attempt in 1..=MAX_ATTEMPTS {
+        match refresh_unity_type_index(project_path).await {
+            Ok(_) => return Ok(()),
+            Err(error) => {
+                last_error = error;
+                eprintln!(
+                    "[Locus] Unity type index refresh after recompile attempt {}/{} failed: {}",
+                    attempt, MAX_ATTEMPTS, last_error
+                );
+                if attempt < MAX_ATTEMPTS {
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+                }
+            }
+        }
+    }
+
+    Err(last_error)
+}
+
 /// Trigger a Unity recompile and wait until the new domain is ready.
 ///
 /// Flow:
@@ -1376,7 +1426,10 @@ pub async fn recompile_and_wait(project_path: &str) -> Result<String, String> {
         );
     }
 
-    let resp = send_message(project_path, "request_recompile", "").await?;
+    let resp = match send_message(project_path, "request_recompile", "").await {
+        Ok(resp) => resp,
+        Err(error) => return finish(Err(error)),
+    };
     if !resp.ok {
         return finish(Err(resp
             .error
@@ -1400,12 +1453,13 @@ pub async fn recompile_and_wait(project_path: &str) -> Result<String, String> {
                 Ok(resp) if resp.ok => {
                     eprintln!("[Locus] Unity reconnected after domain reload");
                     crate::unity_type_index::invalidate_cached_type_index(project_path).await;
-                    transport::disconnect_with_reason(
-                        project_path,
-                        "Unity reconnected after domain reload",
-                    )
-                    .await;
-                    if let Err(error) = refresh_unity_type_index(project_path).await {
+                    if let Err(error) =
+                        wait_for_unity_bridge_ready_after_recompile(project_path).await
+                    {
+                        return finish(Err(error));
+                    }
+                    if let Err(error) = refresh_unity_type_index_after_recompile(project_path).await
+                    {
                         eprintln!(
                             "[Locus] Unity type index refresh after recompile skipped: {}",
                             error
@@ -1429,12 +1483,14 @@ pub async fn recompile_and_wait(project_path: &str) -> Result<String, String> {
                         "ok" => {
                             crate::unity_type_index::invalidate_cached_type_index(project_path)
                                 .await;
-                            transport::disconnect_with_reason(
-                                project_path,
-                                "Unity recompile completed",
-                            )
-                            .await;
-                            if let Err(error) = refresh_unity_type_index(project_path).await {
+                            if let Err(error) =
+                                wait_for_unity_bridge_ready_after_recompile(project_path).await
+                            {
+                                return finish(Err(error));
+                            }
+                            if let Err(error) =
+                                refresh_unity_type_index_after_recompile(project_path).await
+                            {
                                 eprintln!(
                                     "[Locus] Unity type index refresh after recompile skipped: {}",
                                     error

src-tauri/src/unity_bridge/transport.rs

@@ -170,7 +170,13 @@ mod windows_impl {
                 }
             };
 
-            if let Some(reply_to) = env.reply_to.clone() {
+            let reply_to = env
+                .reply_to
+                .clone()
+                .map(|value| value.trim().to_string())
+                .filter(|value| !value.is_empty());
+
+            if let Some(reply_to) = reply_to {
                 let tx = {
                     let mut pending = conn.pending.lock().await;
                     pending.remove(&reply_to)

src/__tests__/chatStatusIndicators.test.ts

@@ -25,6 +25,7 @@ describe("chat status indicators", () => {
     expect(chatView).toContain('@launch-unity-project="emit(\'launchUnityProject\')"');
     expect(chatView).toContain(':unity-launching="unityLaunching"');
     expect(chatView).toContain(':unity-launch-state="unityLaunchState"');
+    expect(chatView).toContain(':unity-recompiling="unityRecompileActive"');
     expect(chatView).toContain("workingDir?: string;");
     expect(chatView).toContain(':working-dir="workingDir"');
     expect(workspace).toContain(':working-dir="projectStore.workingDir"');
@@ -99,8 +100,11 @@ describe("chat status indicators", () => {
     expect(indicators).toContain("unityLaunching?: boolean;");
     expect(indicators).toContain('type UnityLaunchState = "idle" | "starting" | "waitingConnection";');
     expect(indicators).toContain("unityLaunchState?: UnityLaunchState;");
+    expect(indicators).toContain("unityRecompiling?: boolean;");
     expect(indicators).toContain('const unityCanLaunch = computed(() =>');
-    expect(indicators).toContain('!props.unityConnected && !props.unityPluginStatus');
+    expect(indicators).toContain('&& !props.unityConnected');
+    expect(indicators).toContain('&& !props.unityPluginStatus');
+    expect(indicators).toContain('&& !unityRecompileWaitingConnection.value');
     expect(indicators).toContain('const effectiveUnityLaunchState = computed<UnityLaunchState>(() =>');
     expect(indicators).toContain('if (effectiveUnityLaunchState.value === "starting") return t("chat.unity.launching");');
     expect(indicators).toContain('return t("chat.status.unity.waitingConnection");');
@@ -119,4 +123,20 @@ describe("chat status indicators", () => {
     expect(zh).toContain('"chat.status.unity.waitingConnection": "等待连接"');
     expect(zh).toContain('"chat.status.unity.launchTitle": "启动 Unity 项目"');
   });
+
+  it("shows Unity recompile reconnect waits as the accent connection state", () => {
+    const chatView = read("src/components/ChatView.vue");
+    const indicators = read("src/components/chat/ChatStatusIndicators.vue");
+    const zh = read("src/language/zh.json");
+    const en = read("src/language/en.json");
+
+    expect(chatView).toContain("function hasRunningUnityRecompile(calls: ToolCallDisplay[] | undefined): boolean");
+    expect(chatView).toContain('call.name === "unity_recompile" && call.status === "running"');
+    expect(chatView).toContain("const unityRecompileActive = computed(() => hasRunningUnityRecompile(props.activeToolCalls));");
+    expect(indicators).toContain("const unityRecompileWaitingConnection = computed(() =>");
+    expect(indicators).toContain('if (unityRecompileWaitingConnection.value) return t("chat.unity.waitingRecompileConnection");');
+    expect(indicators).toContain('unityRecompileWaitingConnection.value || effectiveUnityLaunchState.value !== "idle"');
+    expect(zh).toContain('"chat.unity.waitingRecompileConnection": "Unity 重编译中，等待重连"');
+    expect(en).toContain('"chat.unity.waitingRecompileConnection": "Unity recompiling, waiting for reconnect"');
+  });
 });

src/__tests__/unityBridgeCompatibility.test.ts

@@ -20,4 +20,15 @@ describe("unityBridgeCompatibility", () => {
     expect(bridge).toContain("server.WaitForConnection();");
     expect(bridge).toContain("ct.Register(delegate");
   });
+
+  it("keeps the Unity bridge connection stable after recompilation", () => {
+    const bridge = read("src-tauri/src/unity_bridge/mod.rs");
+    const transport = read("src-tauri/src/unity_bridge/transport.rs");
+
+    expect(bridge).toContain("wait_for_unity_bridge_ready_after_recompile");
+    expect(bridge).toContain("refresh_unity_type_index_after_recompile");
+    expect(bridge).toContain("Unity reconnected after domain reload");
+    expect(bridge).not.toContain("Unity recompile completed");
+    expect(transport).toContain(".filter(|value| !value.is_empty())");
+  });
 });

src/components/ChatView.vue

@@ -187,6 +187,14 @@ const props = defineProps<{
   sessionPanelStorageScope?: string;
 }>();
 
+function hasRunningUnityRecompile(calls: ToolCallDisplay[] | undefined): boolean {
+  return !!calls?.some((call) =>
+    (call.name === "unity_recompile" && call.status === "running")
+    || hasRunningUnityRecompile(call.nestedToolCalls),
+  );
+}
+
+const unityRecompileActive = computed(() => hasRunningUnityRecompile(props.activeToolCalls));
 
 const emit = defineEmits<{
   send: [text: string, images: ImageAttachment[], assetRefs: AssetRefAttachment[], overrides?: { displayText?: string; mode?: string; userIntent?: UserIntentMeta | null }];
@@ -1484,6 +1492,7 @@ onUnmounted(() => {
             :unity-plugin-installing="unityPluginInstalling"
             :unity-launching="unityLaunching"
             :unity-launch-state="unityLaunchState"
+            :unity-recompiling="unityRecompileActive"
             :working-dir="workingDir"
             :is-unity-project="isUnityProject"
             :scan-phase="scanPhase"

src/components/chat/ChatStatusIndicators.vue

@@ -42,6 +42,7 @@ const props = defineProps<{
   unityPluginInstalling?: boolean;
   unityLaunching?: boolean;
   unityLaunchState?: UnityLaunchState;
+  unityRecompiling?: boolean;
   workingDir?: string;
   isUnityProject?: boolean;
   scanPhase?: AssetDbScanEvent | null;
@@ -124,8 +125,15 @@ const effectiveUnityLaunchState = computed<UnityLaunchState>(() => {
   return props.unityLaunching ? "starting" : "idle";
 });
 
+const unityRecompileWaitingConnection = computed(() =>
+  !!props.unityRecompiling
+  && !props.unityConnected
+  && !props.unityPluginStatus,
+);
+
 const unitySummary = computed(() => {
   if (unityPluginLabel.value) return unityPluginLabel.value;
+  if (unityRecompileWaitingConnection.value) return t("chat.unity.waitingRecompileConnection");
   if (effectiveUnityLaunchState.value === "starting") return t("chat.unity.launching");
   if (effectiveUnityLaunchState.value === "waitingConnection") return t("chat.unity.waitingConnection");
   return props.unityConnected ? t("chat.unity.connected") : t("chat.unity.disconnected");
@@ -136,13 +144,16 @@ const unityTone = computed<StatusTone>(() =>
     ? "danger"
     : props.unityConnected
       ? "success"
-      : effectiveUnityLaunchState.value !== "idle"
+      : unityRecompileWaitingConnection.value || effectiveUnityLaunchState.value !== "idle"
         ? "accent"
         : "danger",
 );
 
 const unityCanLaunch = computed(() =>
-  !!props.isUnityProject && !props.unityConnected && !props.unityPluginStatus,
+  !!props.isUnityProject
+  && !props.unityConnected
+  && !props.unityPluginStatus
+  && !unityRecompileWaitingConnection.value,
 );
 
 const unityActionLabel = computed(() => {
@@ -282,7 +293,9 @@ const statusItems = computed<StatusItem[]>(() => [
     actionTitle: unityActionTitle.value,
     actionDisabled: props.unityPluginStatus
       ? props.unityPluginInstalling
-      : effectiveUnityLaunchState.value !== "idle" || !props.isUnityProject,
+      : unityRecompileWaitingConnection.value
+        || effectiveUnityLaunchState.value !== "idle"
+        || !props.isUnityProject,
     actionVariant: props.unityPluginStatus ? "neutral" : "primary",
   },
 ]);

src/language/en.json

@@ -205,6 +205,7 @@
   "chat.unity.disconnected": "Unity Editor disconnected",
   "chat.unity.launching": "Unity Editor launching",
   "chat.unity.waitingConnection": "Unity Editor launched, waiting for connection",
+  "chat.unity.waitingRecompileConnection": "Unity recompiling, waiting for reconnect",
   "chat.sceneObject.sceneNotLoaded": "Scene not loaded: {0}",
   "chat.sceneObject.objectMissing": "Object not found: {0}",
   "chat.sceneObject.openFailed": "Failed to open scene object: {0}",
@@ -672,8 +673,8 @@
   "settings.custom.reasoningOpenaiChat": "reasoning_effort",
   "settings.custom.reasoningOpenaiResponses": "reasoning.effort",
   "settings.custom.reasoningAnthropic": "Anthropic thinking",
-  "settings.custom.replayReasoningContent": "Replay reasoning_content",
-  "settings.custom.replayReasoningContentHint": "Include prior reasoning in multi-turn tool calls",
+  "settings.custom.replayReasoningContent": "Replay reasoning",
+  "settings.custom.replayReasoningContentHint": "Include historical reasoning in multi-turn tool calls",
   "settings.custom.betaFlags": "Beta Flags",
   "settings.custom.betaFlagsHint": "Anthropic beta headers to include in requests",
   "settings.custom.betaContext1m": "Enable 1M context window",

src/language/zh.json

@@ -205,6 +205,7 @@
   "chat.unity.disconnected": "Unity编辑器未连接",
   "chat.unity.launching": "Unity编辑器启动中",
   "chat.unity.waitingConnection": "Unity编辑器已启动，等待连接",
+  "chat.unity.waitingRecompileConnection": "Unity 重编译中，等待重连",
   "chat.sceneObject.sceneNotLoaded": "场景未加载：{0}",
   "chat.sceneObject.objectMissing": "对象不存在：{0}",
   "chat.sceneObject.openFailed": "无法打开场景对象：{0}",
@@ -672,8 +673,8 @@
   "settings.custom.reasoningOpenaiChat": "reasoning_effort",
   "settings.custom.reasoningOpenaiResponses": "reasoning.effort",
   "settings.custom.reasoningAnthropic": "Anthropic thinking",
-  "settings.custom.replayReasoningContent": "回放 reasoning_content",
-  "settings.custom.replayReasoningContentHint": "多轮工具调用时带回上一轮推理内容",
+  "settings.custom.replayReasoningContent": "回放推理内容",
+  "settings.custom.replayReasoningContentHint": "多轮工具调用时带回历史推理内容",
   "settings.custom.betaFlags": "Beta 标志",
   "settings.custom.betaFlagsHint": "请求中附带的 Anthropic beta 头",
   "settings.custom.betaContext1m": "启用 1M 上下文窗口",