@codex review

Codex Review: Didn't find any major issues. Keep it up!

windows版本上 好像并没有生效 我的mac上是正常的

@Dearli666 @farion1231

Here's a polished comment you can post on the PR:

Impact on DeepSeek Prefix Cache Hit Rate

This PR's system message normalization has a significant side effect on providers that use byte-prefix caching (DeepSeek, Moonshot, etc.). After this change, my cache hit rate dropped from ~95% to ~25% when routing Claude Code through CC Switch to DeepSeek.

Root cause: DeepSeek's context cache requires strict byte-prefix matching from token 0. The current normalize_openai_system_messages logic (transform.rs#L265-L314) does two things that break this:

1. Merging multiple system messages into one — the concatenated result changes across turns as new system instructions appear, invalidating the entire prefix.
2. Repositioning the sole system message to index 0 — while correct for OpenAI compatibility, the merge step above makes the content unstable.

Even a single character drift in the system message (which sits at the very start of the prefix) causes a full cache miss for all subsequent tokens — that's the entire conversation history being re-processed at full price ($0.14/M vs $0.014/M cached).

Proposed fix: For byte-prefix-sensitive providers, instead of merging all system messages into one, keep only the first system message in place and downgrade the rest to role: "user" with a semantic prefix:

fn normalize_openai_system_messages(messages: &mut Vec<Value>) {
    let mut first_system_seen = false;
    for msg in messages.iter_mut() {
        if msg.get("role").and_then(|v| v.as_str()) == Some("system") {
            if !first_system_seen {
                first_system_seen = true;
                // Keep the first system message — it's the stable prefix anchor
            } else {
                // Downgrade subsequent system messages to user role
                // to avoid breaking the byte-prefix chain
                msg["role"] = json!("user");
                if let Some(text) = msg.get("content").and_then(|c| c.as_str()).cloned() {
                    msg["content"] = json!(format!("[System Instruction]\n{}", text));
                }
            }
        }
    }
    // Ensure the first system message is at index 0
    if first_system_seen {
        if let Some(idx) = messages.iter().position(|m| {
            m.get("role").and_then(|v| v.as_str()) == Some("system")
        }) {
            if idx > 0 {
                let m = messages.remove(idx);
                messages.insert(0, m);
            }
        }
    }
}

Why this works:

Important caveat: This strategy should be provider-aware. Claude's prompt cache uses segmented hashing with cache_control breakpoints, so merging system messages doesn't hurt it. The downgrade approach is only beneficial for byte-prefix-cache APIs. A runtime flag (e.g., prefix_cache_sensitive) that selects the strategy per upstream would be the cleanest solution.

This aligns with the direction of #3841 (stripping cache_control on OpenAI conversion paths) — the proxy layer needs to be aware of downstream caching semantics when transforming request formats.