refactor: 重构run_check命令，支持无项目上下文的健康检查

1. 调整run_check流程，无项目配置时返回友好提示而非报错
2. 拆分健康检查和完整验证逻辑，分离项目上下文依赖
3. 优化错误提示信息，区分不同场景下的报错内容

style: 简化tool_call_output的content提取逻辑
refactor: 重构early_stream_failed_response的事件发送顺序
perf: 调整opencode adapter认证超时时间至5秒
test: 新增多项目管理相关测试用例
test: 修复并新增工具调用输出内容校验测试
docs: 更新文档中的超时配置示例

Author: HisenWeb

config.toml.example

@@ -19,7 +19,7 @@ stream_idle_timeout_ms = 120000
 [model_providers.opencode_go_adapter.auth]
 command = "codex-opencode-adapter"
 args = ["auth", "print-local-token"]
-timeout_ms = 1000
+timeout_ms = 5000
 
 [agents.oss_mimo]
 description = "OpenCode Go MiMo worker"

docs/USAGE.zh-CN.md

@@ -92,7 +92,7 @@ codex-opencode-adapter init --api-key "<你的 OpenCode Go API Key>"
 [model_providers.opencode_go_adapter.auth]
 command = "codex-opencode-adapter"
 args = ["auth", "print-local-token"]
-timeout_ms = 1000
+timeout_ms = 5000
 ```
 
 [config.toml.example](../config.toml.example) 是合并模板，不应整份复制成项目

scripts/install-user-provider.ps1

@@ -22,7 +22,7 @@ stream_idle_timeout_ms = 120000
 [model_providers.opencode_go_adapter.auth]
 command = "codex-opencode-adapter"
 args = ["auth", "print-local-token"]
-timeout_ms = 1000
+timeout_ms = 5000
 "@
     exit 0
 }

src/conversion/responses_to_chat.rs

@@ -319,12 +319,8 @@ fn extract_request_with_context(
                     "tool output item received in Responses input"
                 );
                 flush_pending(&mut messages, &mut pending_calls);
-                let content = if kind == "function_call_output" {
-                    let empty = Value::String(String::new());
-                    as_text(obj.get("output").unwrap_or(&empty))
-                } else {
-                    compact_json(&Value::Object(obj.clone()))
-                };
+                let empty = Value::String(String::new());
+                let content = as_text(obj.get("output").unwrap_or(&empty));
                 tool_outputs.push(json!({
                     "role":"tool",
                     "tool_call_id":call_id,

src/init.rs

@@ -174,7 +174,7 @@ fn build_global_codex_config(path: &Path, port: u16) -> anyhow::Result<String> {
     args.push("auth");
     args.push("print-local-token");
     auth["args"] = Item::Value(args.into());
-    auth["timeout_ms"] = value(1000);
+    auth["timeout_ms"] = value(5000);
 
     Ok(document.to_string())
 }

src/main.rs

@@ -126,32 +126,69 @@ async fn run_server(args: RunArgs) -> anyhow::Result<()> {
 }
 
 async fn run_check() -> anyhow::Result<()> {
-    let config = load_project_config(RunArgs::default())?;
-    let raw_token = config
-        .local_token
-        .as_deref()
-        .filter(|v| !v.is_empty())
-        .ok_or_else(|| anyhow::anyhow!("CODEX_OPENCODE_LOCAL_TOKEN is missing"))?;
-    let signed_token = sign_adapter_token(raw_token);
-
-    let base = format!("http://{}:{}", config.host, config.port);
     let client = reqwest::Client::new();
+
+    // Phase 1: Resolve project context for host/port/token.
+    // If no project context is available, fall back to defaults for a basic health check.
+    let (base, config) = match load_project_config(RunArgs::default()) {
+        Ok(config) => {
+            let base = format!("http://{}:{}", config.host, config.port);
+            (base, Some(config))
+        }
+        Err(error) => {
+            eprintln!("Warning: could not load project config: {error}");
+            let base = format!("http://{}:{}", DEFAULT_HOST, DEFAULT_PORT);
+            (base, None)
+        }
+    };
+
+    // Phase 2: Health check works without project context.
     let health = client
         .get(format!("{base}/health"))
         .send()
         .await
         .map_err(|_| {
-            anyhow::anyhow!("Adapter is not running. Start it with 'codex-opencode-adapter run' or 'codex-opencode-adapter start'.")
+            if config.is_some() {
+                anyhow::anyhow!(
+                    "Adapter is not running at {base}. Start it with 'codex-opencode-adapter run' or 'codex-opencode-adapter start'."
+                )
+            } else {
+                anyhow::anyhow!(
+                    "Could not reach adapter at {base}.\n\
+                     Either start the adapter, or run from a project directory / set CODEX_OPENCODE_PROJECT_ID\n\
+                     to check the correct host/port from your project configuration."
+                )
+            }
         })?;
-    anyhow::ensure!(health.status().is_success(), "health check failed");
+    anyhow::ensure!(health.status().is_success(), "health check failed at {base}");
+    println!("\u{2713} Adapter health check passed at {base}");
+
+    // Phase 3: Models check requires project context.
+    match config {
+        Some(config) => {
+            let raw_token = config
+                .local_token
+                .as_deref()
+                .filter(|v| !v.is_empty())
+                .ok_or_else(|| anyhow::anyhow!("CODEX_OPENCODE_LOCAL_TOKEN is missing in project config"))?;
+            let signed_token = sign_adapter_token(raw_token);
+
+            let models = client
+                .get(format!("{base}/v1/models"))
+                .bearer_auth(&signed_token)
+                .send()
+                .await?;
+            anyhow::ensure!(models.status().is_success(), "/v1/models check failed");
+            println!("\u{2713} Models endpoint verified");
+            println!("Adapter check passed.");
+        }
+        None => {
+            println!("\u{2713} Adapter is reachable.");
+            println!("  For full verification including /v1/models, run from a project directory");
+            println!("  or set CODEX_OPENCODE_PROJECT_ID to your project ID.");
+        }
+    }
 
-    let models = client
-        .get(format!("{base}/v1/models"))
-        .bearer_auth(&signed_token)
-        .send()
-        .await?;
-    anyhow::ensure!(models.status().is_success(), "/v1/models check failed");
-    println!("Adapter check passed.");
     Ok(())
 }
 

src/server.rs

@@ -666,25 +666,40 @@ async fn admin_refresh(State(state): State<AppState>, headers: HeaderMap) -> Res
 
     let mut projects = state.projects.write().unwrap();
     let mut added = Vec::new();
-    let mut skipped = Vec::new();
+    let mut already_loaded = Vec::new();
+    let mut failed = Vec::new();
+
+    // Remove projects that no longer exist in the registry.
+    let mut removed = Vec::new();
+    let to_remove: Vec<String> = projects
+        .keys()
+        .filter(|id| !registry.projects.contains_key(id.as_str()))
+        .cloned()
+        .collect();
+    for id in &to_remove {
+        projects.remove(id);
+        removed.push(id.clone());
+    }
 
     for (project_id, entry) in &registry.projects {
         if projects.contains_key(project_id) {
-            skipped.push(project_id.clone());
+            already_loaded.push(project_id.clone());
             continue;
         }
 
         let root = PathBuf::from(&entry.root);
         let env_path = root.join(PROJECT_ENV_FILENAME);
         if !env_path.exists() {
             tracing::warn!("refresh: project {project_id} missing env file, skipping");
+            failed.push(json!({"project_id": project_id, "reason": "missing env file"}));
             continue;
         }
 
         let project_env = match read_project_env(&env_path) {
             Ok(e) => e,
             Err(e) => {
                 tracing::warn!("refresh: cannot read env for {project_id}: {e}");
+                failed.push(json!({"project_id": project_id, "reason": format!("read env failed: {e}")}));
                 continue;
             }
         };
@@ -694,6 +709,7 @@ async fn admin_refresh(State(state): State<AppState>, headers: HeaderMap) -> Res
             Ok(c) => c,
             Err(e) => {
                 tracing::warn!("refresh: bad config for {project_id}: {e}");
+                failed.push(json!({"project_id": project_id, "reason": format!("bad config: {e}")}));
                 continue;
             }
         };
@@ -705,6 +721,7 @@ async fn admin_refresh(State(state): State<AppState>, headers: HeaderMap) -> Res
             Ok(s) => s,
             Err(e) => {
                 tracing::warn!("refresh: cannot create state for {project_id}: {e}");
+                failed.push(json!({"project_id": project_id, "reason": format!("state init failed: {e}")}));
                 continue;
             }
         };
@@ -716,6 +733,7 @@ async fn admin_refresh(State(state): State<AppState>, headers: HeaderMap) -> Res
             Ok(c) => c,
             Err(e) => {
                 tracing::warn!("refresh: cannot create client for {project_id}: {e}");
+                failed.push(json!({"project_id": project_id, "reason": format!("client init failed: {e}")}));
                 continue;
             }
         };
@@ -730,7 +748,7 @@ async fn admin_refresh(State(state): State<AppState>, headers: HeaderMap) -> Res
         added.push(project_id.clone());
     }
 
-    Json(json!({"status":"ok","added":added,"already_loaded":skipped})).into_response()
+    Json(json!({"status":"ok","added":added,"already_loaded":already_loaded,"removed":removed,"failed":failed})).into_response()
 }
 
 fn parse_routed_model(model: &str) -> Result<(String, String), &'static str> {
@@ -810,13 +828,23 @@ fn early_stream_failed_response(
     kind: &'static str,
     message: &str,
 ) -> Response {
+    let response_id = format!("resp_{}", Uuid::new_v4().simple());
+    let created_at = now_ts();
+    let shell = json!({"id":response_id,"object":"response","created_at":created_at,"status":"in_progress","error":null,"incomplete_details":null,"instructions":body.get("instructions").cloned().unwrap_or(Value::Null),"model":model_alias,"output":[],"parallel_tool_calls":body.get("parallel_tool_calls").and_then(Value::as_bool).unwrap_or(false),"previous_response_id":body.get("previous_response_id").cloned().unwrap_or(Value::Null),"store":false,"usage":{"input_tokens":0,"output_tokens":0,"total_tokens":0},"metadata":body.get("metadata").cloned().unwrap_or_else(|| json!({}))});
     let (tx, rx) =
         tokio::sync::mpsc::unbounded_channel::<Result<axum::response::sse::Event, Infallible>>();
-    let response = responses_failed_value(&body, &model_alias, kind, message);
-    let event = json!({"type":"response.failed","response":response});
+    let _ = tx.send(Ok(axum::response::sse::Event::default()
+        .event("response.created")
+        .data(json!({"type":"response.created","response":shell.clone()}).to_string())));
+    let _ = tx.send(Ok(axum::response::sse::Event::default()
+        .event("response.in_progress")
+        .data(json!({"type":"response.in_progress","response":shell.clone()}).to_string())));
+    let mut failed_response = shell;
+    failed_response["status"] = json!("failed");
+    failed_response["error"] = json!({"type":kind,"code":kind,"message":message.chars().take(1000).collect::<String>()});
     let _ = tx.send(Ok(axum::response::sse::Event::default()
         .event("response.failed")
-        .data(event.to_string())));
+        .data(json!({"type":"response.failed","response":failed_response}).to_string())));
     let _ = tx.send(Ok(axum::response::sse::Event::default().data("[DONE]")));
     let stream = tokio_stream::wrappers::UnboundedReceiverStream::new(rx);
     Sse::new(stream).into_response()

tests/cli_distribution_flow.rs

@@ -95,7 +95,7 @@ wire_api = "responses"
 [model_providers.opencode_go_adapter.auth]
 command = "cmd.exe"
 args = ["/d", "/s", "/c", "echo old"]
-timeout_ms = 1000
+timeout_ms = 5000
 "#;
     fs::write(&config_path, original).unwrap();
 
@@ -247,6 +247,37 @@ fn auth_rejects_recovered_project_when_registry_mismatches_env() {
     );
 }
 
+// ---------------------------------------------------------------------------
+// Test: check without project context falls through to health check
+#[test]
+fn check_without_project_context_shows_connectivity_error() {
+    let sandbox = TestSandbox::new("check-no-context");
+    // No init means no projects at all and no env file.
+    let external_dir = sandbox.root().join("external");
+    fs::create_dir_all(&external_dir).unwrap();
+
+    let output = sandbox.run_in(&external_dir, ["check"]);
+    let stderr_text = stderr(&output);
+    let stdout_text = stdout(&output);
+
+    // Must never mention "Project is not initialized"; that was the original bug.
+    assert!(
+        !stderr_text.contains("Project is not initialized"),
+        "must not mention project init: {stderr_text}"
+    );
+    // The warning prints the original config error, so "No OpenCode" is
+    // expected in stderr.  It must NOT appear in stdout though.
+    assert!(
+        !stdout_text.contains("No OpenCode"),
+        "must not mention 'no projects' in stdout: {stdout_text}"
+    );
+    // Verify the warning is present so the user knows why.
+    assert!(
+        stderr_text.contains("Warning: could not load project config"),
+        "stderr should contain config resolution warning: {stderr_text}"
+    );
+}
+
 #[test]
 fn check_uses_project_env_and_succeeds() {
     let sandbox = TestSandbox::new("check-success");

tests/common/mod.rs

@@ -10,7 +10,7 @@ use codex_opencode_adapter::upstream::OpenCodeGoClient;
 use serde_json::{json, Value};
 use std::collections::HashMap;
 use std::net::SocketAddr;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, OnceLock, RwLock};
 use tokio::net::TcpListener;
 use tokio::sync::Semaphore;
 use uuid::Uuid;
@@ -108,6 +108,14 @@ pub fn adapter_url(addr: SocketAddr, path: &str) -> String {
     format!("http://{}{}", addr, path)
 }
 
+/// A global lock for tests that modify HOME/USERPROFILE environment variables.
+/// Concurrent tests within the same binary that set these env vars would
+/// otherwise overwrite each other's values, causing flaky failures.
+pub fn env_lock() -> &'static tokio::sync::Mutex<()> {
+    static LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
+}
+
 pub struct RealSmokeConfig {
     pub upstream_base: String,
     pub upstream_key: String,