Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

11.7 KB
Raw Blame
//! Completion dispatch for OpenCode's advertised API protocols.
//!
//! Callers supply credentials, provider identity, and transport configuration,
//! keeping application settings and UI dependencies outside this crate.

use anthropic::completion::{AnthropicEventMapper, AnthropicPromptCacheMode, into_anthropic};
use futures::StreamExt;
use google_ai::completion::{GoogleEventMapper, into_google};
use http_client::{CustomHeaders, HttpClient};
use language_model_core::{
    LanguageModelCompletionError, LanguageModelCompletionStream, LanguageModelProviderId,
    LanguageModelProviderName, LanguageModelRequest, ReasoningEffort,
    chat_completion::ChatCompletionEventMapper,
};
use open_ai::completion::{
    ChatCompletionMaxTokensParameter, OpenAiResponseEventMapper, into_open_ai,
    into_open_ai_response,
};

use crate::{
    ApiProtocol,
    catalog::{DiscoveredModel, normalize_reasoning_effort},
};

/// Transport and identity for a completion, independent of application settings.
pub struct CompletionConfig<'a> {
    pub model: &'a DiscoveredModel,
    pub api_url: &'a str,
    pub api_key: &'a str,
    pub provider_id: LanguageModelProviderId,
    pub provider_name: LanguageModelProviderName,
    pub custom_headers: &'a CustomHeaders,
}

/// Converts a request and streams it using the model's advertised protocol.
///
/// Errors retain provider details for the caller's presentation and retry policy.
pub async fn stream_completion(
    client: &dyn HttpClient,
    config: CompletionConfig<'_>,
    mut request: LanguageModelRequest,
) -> Result<LanguageModelCompletionStream, LanguageModelCompletionError> {
    let model = &config.model.model;
    let api_url = config.api_url.trim_end_matches('/');
    match model.protocol() {
        ApiProtocol::Anthropic => {
            let mode = if config.model.supports_thinking && request.thinking_allowed {
                anthropic::AnthropicModelMode::AdaptiveThinking
            } else {
                anthropic::AnthropicModelMode::Default
            };
            let mut request = into_anthropic(
                request,
                model.id().to_string(),
                1.0,
                model.max_output_tokens().unwrap_or(8192),
                mode,
                AnthropicPromptCacheMode::Automatic,
                &config.provider_id,
            )?;
            // OpenCode's Anthropic endpoint rejects the thinking-binding beta option.
            if let Some(anthropic::Thinking::Adaptive { block_binding, .. }) = &mut request.thinking
            {
                *block_binding = None;
            }
            let stream = anthropic::stream_completion(
                client,
                api_url,
                config.api_key,
                request,
                None,
                config.custom_headers,
            )
            .await?;
            Ok(
                AnthropicEventMapper::new(config.provider_name, config.provider_id)
                    .map_stream(stream.boxed())
                    .boxed(),
            )
        }
        ApiProtocol::OpenAiChat => {
            let effort = request
                .thinking_allowed
                .then(|| {
                    request
                        .thinking_effort
                        .as_deref()
                        .and_then(normalize_reasoning_effort)
                })
                .flatten();
            let mut request = into_open_ai(
                request,
                model.id(),
                true,
                false,
                model.max_output_tokens(),
                ChatCompletionMaxTokensParameter::MaxCompletionTokens,
                effort,
                model.interleaved_reasoning(),
            )?;
            prepare_deepseek_reasoning_content(&mut request, model.interleaved_reasoning());
            let stream = open_ai::stream_completion(
                client,
                config.provider_name.0.as_ref(),
                &format!("{api_url}/v1"),
                config.api_key,
                request,
                config.custom_headers,
            )
            .await?;
            Ok(ChatCompletionEventMapper::new()
                .map_stream(stream.boxed())
                .boxed())
        }
        ApiProtocol::OpenAiResponses => {
            let supports_none = model
                .supported_reasoning_effort_levels()
                .is_some_and(|levels| levels.contains(&ReasoningEffort::None));
            let request = into_open_ai_response(
                request,
                model.id(),
                true,
                false,
                model.max_output_tokens(),
                None,
                supports_none,
                &config.provider_id,
            )?;
            let stream = open_ai::responses::stream_response(
                client,
                config.provider_name.0.as_ref(),
                &format!("{api_url}/v1"),
                config.api_key,
                request,
                config.custom_headers,
            )
            .await?;
            Ok(OpenAiResponseEventMapper::new(config.provider_id)
                .map_stream(stream.boxed())
                .boxed())
        }
        ApiProtocol::Google => {
            if request.max_output_tokens.is_some() {
                request.max_output_tokens =
                    request.effective_max_output_tokens(model.max_output_tokens());
            }
            let mode = if config.model.supports_thinking && request.thinking_allowed {
                google_ai::GoogleModelMode::Thinking {
                    budget_tokens: None,
                }
            } else {
                google_ai::GoogleModelMode::Default
            };
            let request = into_google(request, model.id().to_string(), mode)?;
            let stream = crate::stream_generate_content(
                client,
                api_url,
                config.api_key,
                request,
                config.custom_headers,
            )
            .await?;
            Ok(GoogleEventMapper::new().map_stream(stream.boxed()).boxed())
        }
    }
}

/// Keeps DeepSeek's required reasoning field on every assistant message.
///
/// Empty reasoning is not retained in conversation history, but DeepSeek still
/// requires the field when replaying an assistant tool call.
pub fn prepare_deepseek_reasoning_content(
    request: &mut open_ai::Request,
    interleaved_reasoning: bool,
) {
    if !interleaved_reasoning || !request.model.starts_with("deepseek-") {
        return;
    }
    for message in &mut request.messages {
        if let open_ai::RequestMessage::Assistant {
            reasoning_content, ..
        } = message
        {
            reasoning_content.get_or_insert_default();
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use anyhow::Result;
    use futures::{AsyncReadExt, TryStreamExt};
    use http_client::{AsyncBody, FakeHttpClient, Response, http};
    use language_model_core::{
        LanguageModelCompletionEvent, LanguageModelRequestMessage, MessageContent, Role,
    };

    #[test]
    fn completion_dispatches_protocols_and_maps_streamed_text() -> Result<()> {
        for (protocol, model_id, path, response) in [
            (
                ApiProtocol::Anthropic,
                "claude-fable-5-1",
                "/zen/go/v1/messages",
                "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Hello\"}}\n\n",
            ),
            (
                ApiProtocol::OpenAiChat,
                "model",
                "/zen/go/v1/chat/completions",
                "data: {\"id\":\"chat-1\",\"object\":\"chat.completion.chunk\",\"created\":0,\"model\":\"model\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"},\"finish_reason\":null}]}\n\ndata: [DONE]\n\n",
            ),
            (
                ApiProtocol::OpenAiResponses,
                "model",
                "/zen/go/v1/responses",
                "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"item_id\":\"msg-1\",\"output_index\":0,\"content_index\":0,\"delta\":\"Hello\"}\n\n",
            ),
            (
                ApiProtocol::Google,
                "model",
                "/zen/go/v1/models/model:streamGenerateContent",
                "data: {\"candidates\":[{\"content\":{\"role\":\"model\",\"parts\":[{\"text\":\"Hello\"}]},\"finishReason\":\"STOP\"}]}\n\n",
            ),
        ] {
            futures::executor::block_on(async {
                let client = FakeHttpClient::create(move |mut request| async move {
                    assert_eq!(request.uri().path(), path);
                    assert_eq!(
                        request.headers().get("x-custom"),
                        Some(&http::HeaderValue::from_static("value"))
                    );
                    let mut body = String::new();
                    request.body_mut().read_to_string(&mut body).await?;
                    let body: serde_json::Value = serde_json::from_str(&body)?;
                    if protocol != ApiProtocol::Google {
                        assert_eq!(body["model"], model_id);
                    }
                    if protocol == ApiProtocol::Anthropic {
                        assert_eq!(body["thinking"]["type"], "adaptive");
                        assert!(body.pointer("/thinking/block_binding").is_none());
                    }
                    Ok(Response::builder()
                        .status(200)
                        .body(AsyncBody::from(response))?)
                });
                let model = DiscoveredModel {
                    model: crate::Model::new(
                        model_id.into(),
                        None,
                        1000,
                        Some(100),
                        protocol,
                        None,
                        None,
                        false,
                    ),
                    supports_images: false,
                    supports_thinking: protocol == ApiProtocol::Anthropic,
                };
                let headers = CustomHeaders::new(vec![(
                    http::HeaderName::from_static("x-custom"),
                    http::HeaderValue::from_static("value"),
                )]);
                let request = LanguageModelRequest {
                    thinking_allowed: true,
                    messages: vec![LanguageModelRequestMessage {
                        role: Role::User,
                        content: vec![MessageContent::Text("Hi".into())],
                        cache: false,
                        reasoning_details: None,
                    }],
                    ..Default::default()
                };
                let events = stream_completion(
                    client.as_ref(),
                    CompletionConfig {
                        model: &model,
                        api_url: "https://opencode.ai/zen/go/",
                        api_key: "test-key",
                        provider_id: LanguageModelProviderId::new("opencode-go"),
                        provider_name: LanguageModelProviderName::new("OpenCode Go"),
                        custom_headers: &headers,
                    },
                    request,
                )
                .await?
                .try_collect::<Vec<_>>()
                .await?;
                let text = events
                    .into_iter()
                    .filter_map(|event| match event {
                        LanguageModelCompletionEvent::Text(text) => Some(text),
                        _ => None,
                    })
                    .collect::<String>();
                assert_eq!(text, "Hello", "{protocol:?}");
                anyhow::Ok(())
            })?;
        }
        Ok(())
    }
}