DeepSeek native API appears incompatible with provider/model model routing

[wduo87391]

Description

When using DeepSeek's official OpenAI-compatible endpoint:

export OPENAI_API_KEY=...
export OPENAI_BASE_URL=https://api.deepseek.com/v1

Claw requires model identifiers in provider/model format:

claw --model openai/deepseek-v4-flash

However DeepSeek's official API expects model names such as:

deepseek-v4-flash
deepseek-v4-pro

and does not appear to accept the prefixed form.

At the same time, attempting to use the native model name directly:

claw --model deepseek-v4-flash

fails client-side with:

[error-kind: invalid_model_syntax]
error: invalid model syntax: 'deepseek-v4-flash'.
Expected provider/model
What was tested

Environment:

export OPENAI_BASE_URL=https://api.deepseek.com/v1
export OPENAI_API_KEY=...

Result:

claw --model deepseek-v4-flash

returns:

invalid model syntax
Expected provider/model

and

claw --model openai/deepseek-v4-flash

does not work against DeepSeek native API.

Additional observations

The same Claw build works correctly with other OpenAI-compatible providers.

For example, using a third-party OpenAI-compatible platform with:

claw --model deepseek-ai/deepseek-v4-flash

successfully reaches the provider and returns provider-side responses.

This suggests the issue may be specific to DeepSeek native API routing/model-name translation rather than the generic OpenAI-compatible implementation.

Question

Should Claw automatically translate:

openai/deepseek-v4-flash

into:

deepseek-v4-flash

when OPENAI_BASE_URL points to DeepSeek's official endpoint?

Or is there currently another supported way to use DeepSeek native models?

[marco-peach-melba]

same question

[marco-peach-melba]

solved

frist，in“rust/crates/api/src/providers/mod.rs”
line298，add

#[must_use]
pub fn downstream_model_name(canonical_model: &str) -> String {
    if let Some(stripped) = canonical_model.strip_prefix("openai/") {
        stripped.to_string()
    } else {
        canonical_model.to_string()
    }
}

then，in “rust/crates/api/src/providers/openai_compat.rs”
line 19 replace with

use super::{preflight_message_request, Provider, ProviderFuture, resolve_model_alias, downstream_model_name};

start from line 214,
send_message and stream_message, replace with

pub async fn send_message(
        &self,
        request: &MessageRequest,
    ) -> Result<MessageResponse, ApiError> {
        let original_model = request.model.clone();
        let canonical = resolve_model_alias(&request.model);
        let downstream_model = downstream_model_name(&canonical);

        let mut request = MessageRequest {
            stream: false,
            ..request.clone()
        };
        request.model = downstream_model;
        preflight_message_request(&request)?;
        let response = self.send_with_retry(&request).await?;
        let request_id = request_id_from_headers(response.headers());
        let body = response.text().await.map_err(ApiError::from)?;
        if let Ok(raw) = serde_json::from_str::<serde_json::Value>(&body) {
            if let Some(err_obj) = raw.get("error") {
                let msg = err_obj
                    .get("message")
                    .and_then(|m| m.as_str())
                    .unwrap_or("provider returned an error")
                    .to_string();
                let code = err_obj
                    .get("code")
                    .and_then(serde_json::Value::as_u64)
                    .map(|c| c as u16);
                return Err(ApiError::Api {
                    status: reqwest::StatusCode::from_u16(code.unwrap_or(400))
                        .unwrap_or(reqwest::StatusCode::BAD_REQUEST),
                    error_type: err_obj
                        .get("type")
                        .and_then(|t| t.as_str())
                        .map(str::to_owned),
                    message: Some(msg),
                    request_id,
                    body,
                    retryable: false,
                    suggested_action: suggested_action_for_status(
                        reqwest::StatusCode::from_u16(code.unwrap_or(400))
                            .unwrap_or(reqwest::StatusCode::BAD_REQUEST),
                    ),
                    retry_after: None,
                });
            }
        }

        let payload = serde_json::from_str::<ChatCompletionResponse>(&body).map_err(|error| {
            ApiError::json_deserialize(self.config.provider_name, &original_model, &body, error)
        })?;
        let mut normalized = normalize_response(&request.model, payload)?;
        if normalized.request_id.is_none() {
            normalized.request_id = request_id;
        }

        normalized.model = original_model;

        Ok(normalized)
    }

    pub async fn stream_message(
        &self,
        request: &MessageRequest,
    ) -> Result<MessageStream, ApiError> {
        let original_model = request.model.clone();

        let canonical = resolve_model_alias(&request.model);
        let downstream_model = downstream_model_name(&canonical);

        let mut streaming_request = request.clone().with_streaming();
        streaming_request.model = downstream_model;

        preflight_message_request(&streaming_request)?;
        let response = self.send_with_retry(&streaming_request).await?;

        Ok(MessageStream {
            request_id: request_id_from_headers(response.headers()),
            response,
            parser: OpenAiSseParser::with_context(self.config.provider_name, original_model.clone()),
            pending: VecDeque::new(),
            done: false,
            state: StreamState::new(original_model),
        })
    }

finally, cargo build --workspace

[marco-peach-melba]

Temporary plan does not represent the final modification

[1716775457damn]

I can confirm this is a real compatibility gap. The root cause is that Claw enforces a provider/model format at the client side, but DeepSeek's native API uses flat model names like deepseek-v4-flash without the provider prefix.

Two possible approaches to fix this:

1. Provider-aware model mapping — when OPENAI_BASE_URL matches �pi.deepseek.com, automatically strip the provider/ prefix before sending to the API. This could be done via a configurable model name mapping table.
2. Special deepseek provider type — treat DeepSeek as a first-class provider (similar to openai, �nthropic) that knows to use flat model names internally.

As a temporary workaround, you could route through a lightweight proxy (like litellm or a simple nginx rewrite) that strips the openai/ prefix. But for a native solution, approach 1 seems simplest — just add a model_name_rewrite mapping for known providers whose APIs don't follow the provider/model convention.

[1716775457damn]

Confirmed fixed by #3232 - the provider prefix stripping resolves the DeepSeek routing issue. Closing.