Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
opencode: Share catalog parsing and completion dispatch (#65922)
Bennet Bo Fenner41e9dc5837f7
diff --git a/Cargo.lock b/Cargo.lockindex 610dbc61920..11eaf42763d 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -12386,11 +12386,14 @@ dependencies = [name = "opencode"version = "0.1.0"dependencies = [+ "anthropic","anyhow","futures 0.3.34","google_ai","http_client","language_model_core",+ "log",+ "open_ai","schemars 1.0.4","serde","serde_json",diff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rsindex 3f2e954d722..2b3cc4495d5 100644--- a/crates/language_models/src/provider/opencode.rs+++ b/crates/language_models/src/provider/opencode.rs@@ -13,10 +13,10 @@ use language_model::{LanguageModelEffortLevel, LanguageModelId, LanguageModelName, LanguageModelProvider,LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState,LanguageModelRequest, LanguageModelToolChoiceSupport, ModelRateLimiters, ProviderSettingsView,- RateLimiter, ReasoningEffort, SubPageProviderSettings, env_var, unavailable_error,+ ReasoningEffort, SubPageProviderSettings, env_var, unavailable_error,};+use opencode::catalog::{DiscoveredModel, MODEL_CATALOG_URL as RICH_MODEL_CATALOG_URL};use opencode::{ApiProtocol, OPENCODE_API_URL, OpenCodeSubscription};-use serde::Deserialize;pub use settings::OpenCodeApiProtocol;pub use settings::OpenCodeAvailableModel as AvailableModel;use settings::{Settings, SettingsStore, update_settings_file};@@ -32,27 +32,6 @@ use ui::{use ui_input::InputField;use util::ResultExt;-use crate::provider::anthropic::{AnthropicEventMapper, into_anthropic};-use crate::provider::google::{GoogleEventMapper, into_google};-use crate::provider::open_ai::{- ChatCompletionMaxTokensParameter, OpenAiResponseEventMapper, into_open_ai,- into_open_ai_response,-};-use language_model::chat_completion::{ChatCompletionEventMapper, ResponseStreamEvent};--fn normalize_reasoning_effort(effort: &str) -> Option<ReasoningEffort> {- match effort.trim().to_ascii_lowercase().as_str() {- "none" => Some(ReasoningEffort::None),- "minimal" => Some(ReasoningEffort::Minimal),- "low" => Some(ReasoningEffort::Low),- "medium" => Some(ReasoningEffort::Medium),- "high" => Some(ReasoningEffort::High),- "xhigh" => Some(ReasoningEffort::XHigh),- "max" => Some(ReasoningEffort::Max),- _ => None,- }-}-fn reasoning_effort_display(effort: ReasoningEffort) -> (&'static str, &'static str) {match effort {ReasoningEffort::None => ("None", "none"),@@ -77,7 +56,6 @@ const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new(const API_KEY_ENV_VAR_NAME: &str = "OPENCODE_API_KEY";static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);const OPENCODE_SESSION_HEADER_NAME: &str = "x-opencode-session";-const RICH_MODEL_CATALOG_URL: &str = "https://models.opencode.ai/api.json";const MODEL_CATALOG_RESPONSE_LIMIT_BYTES: u64 = 8 * 1024 * 1024;const MODEL_CATALOG_FETCH_TIMEOUT: Duration = Duration::from_secs(15);const MODEL_CATALOG_DISK_FRESHNESS: Duration = Duration::from_secs(5 * 60);@@ -111,13 +89,6 @@ pub struct State {fs: Arc<dyn Fs>,}-#[derive(Clone)]-struct DiscoveredModel {- model: opencode::Model,- supports_images: bool,- supports_thinking: bool,-}-impl State {fn is_authenticated(&self) -> bool {self.api_key_state.has_key()@@ -491,164 +462,6 @@ impl OpenCodeLanguageModelProvider {})}- fn stream_anthropic(- &self,- config: &DiscoveredModel,- subscription: OpenCodeSubscription,- request_limiter: &RateLimiter,- request: anthropic::Request,- http_client: Arc<dyn HttpClient>,- extra_headers: CustomHeaders,- cx: &AsyncApp,- ) -> BoxFuture<- 'static,- Result<- futures::stream::BoxStream<- 'static,- Result<anthropic::Event, anthropic::AnthropicError>,- >,- LanguageModelCompletionError,- >,- > {- // Anthropic crate appends /v1/messages to api_url- let api_url = self.base_api_url(config, subscription, cx);- let api_key = self.current_api_key(cx);-- let future = request_limiter.stream(async move {- let Some(api_key) = api_key else {- return Err(LanguageModelCompletionError::NoApiKey {- provider: PROVIDER_NAME,- });- };- let request = anthropic::stream_completion(- http_client.as_ref(),- &api_url,- &api_key,- request,- None,- &extra_headers,- );- let response = request.await?;- Ok(response)- });-- async move { Ok(future.await?.boxed()) }.boxed()- }-- fn stream_openai_chat(- &self,- config: &DiscoveredModel,- subscription: OpenCodeSubscription,- request_limiter: &RateLimiter,- request: open_ai::Request,- http_client: Arc<dyn HttpClient>,- extra_headers: CustomHeaders,- cx: &AsyncApp,- ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponseStreamEvent>>>>- {- // OpenAI crate appends /chat/completions to api_url, so we pass base + "/v1"- let base_url = self.base_api_url(config, subscription, cx);- let api_url: SharedString = format!("{base_url}/v1").into();- let api_key = self.current_api_key(cx);- let provider_name = PROVIDER_NAME.0.to_string();-- let future = request_limiter.stream(async move {- let Some(api_key) = api_key else {- return Err(LanguageModelCompletionError::NoApiKey {- provider: PROVIDER_NAME,- });- };- let request = open_ai::stream_completion(- http_client.as_ref(),- &provider_name,- &api_url,- &api_key,- request,- &extra_headers,- );- let response = request.await?;- Ok(response)- });-- async move { Ok(future.await?.boxed()) }.boxed()- }-- fn stream_openai_response(- &self,- config: &DiscoveredModel,- subscription: OpenCodeSubscription,- request_limiter: &RateLimiter,- request: open_ai::responses::Request,- http_client: Arc<dyn HttpClient>,- extra_headers: CustomHeaders,- cx: &AsyncApp,- ) -> BoxFuture<- 'static,- Result<futures::stream::BoxStream<'static, Result<open_ai::responses::StreamEvent>>>,- > {- // Responses crate appends /responses to api_url, so we pass base + "/v1"- let base_url = self.base_api_url(config, subscription, cx);- let api_url: SharedString = format!("{base_url}/v1").into();- let api_key = self.current_api_key(cx);- let provider_name = PROVIDER_NAME.0.to_string();-- let future = request_limiter.stream(async move {- let Some(api_key) = api_key else {- return Err(LanguageModelCompletionError::NoApiKey {- provider: PROVIDER_NAME,- });- };- let request = open_ai::responses::stream_response(- http_client.as_ref(),- &provider_name,- &api_url,- &api_key,- request,- &extra_headers,- );- let response = request.await?;- Ok(response)- });-- async move { Ok(future.await?.boxed()) }.boxed()- }-- fn stream_google(- &self,- config: &DiscoveredModel,- subscription: OpenCodeSubscription,- request_limiter: &RateLimiter,- request: google_ai::GenerateContentRequest,- http_client: Arc<dyn HttpClient>,- extra_headers: CustomHeaders,- cx: &AsyncApp,- ) -> BoxFuture<- 'static,- Result<futures::stream::BoxStream<'static, Result<google_ai::GenerateContentResponse>>>,- > {- let api_url = self.base_api_url(config, subscription, cx);- let api_key = self.current_api_key(cx);-- let future = request_limiter.stream(async move {- let Some(api_key) = api_key else {- return Err(LanguageModelCompletionError::NoApiKey {- provider: PROVIDER_NAME,- });- };- let request = opencode::stream_generate_content(- http_client.as_ref(),- &api_url,- &api_key,- request,- &extra_headers,- );- let response = request.await?;- Ok(response)- });-- async move { Ok(future.await?.boxed()) }.boxed()- }-pub fn settings(cx: &App) -> &OpenCodeSettings {&crate::AllLanguageModelSettings::get_global(cx).opencode}@@ -749,156 +562,38 @@ impl LanguageModelClient for OpenCodeLanguageModelProvider {});let extra_headers = self.custom_headers(cx);- match config.model.protocol() {- ApiProtocol::Anthropic => {- let mode = if config.supports_thinking && request.thinking_allowed {- anthropic::AnthropicModelMode::AdaptiveThinking- } else {- anthropic::AnthropicModelMode::Default- };- let anthropic_request = match into_anthropic(- request,- config.model.id().to_string(),- 1.0,- config.model.max_output_tokens().unwrap_or(8192),- mode,- anthropic::completion::AnthropicPromptCacheMode::Automatic,- &PROVIDER_ID,- ) {- Ok(request) => request,- Err(error) => return async move { Err(error.into()) }.boxed(),- };- let stream = self.stream_anthropic(- &config,- subscription,- &request_limiter,- anthropic_request,- http_client,- extra_headers,- cx,- );- let executor = cx.background_executor().clone();- async move {- let mapper = AnthropicEventMapper::new(PROVIDER_NAME, PROVIDER_ID);- Ok(language_model::stream_in_background(- mapper.map_stream(stream.await?).boxed(),- executor,- ))- }- .boxed()- }- ApiProtocol::OpenAiChat => {- let reasoning_effort = if request.thinking_allowed {- request- .thinking_effort- .as_deref()- .and_then(normalize_reasoning_effort)- } else {- None- };- let openai_request = match into_open_ai(- request,- config.model.id(),- true,- false,- config.model.max_output_tokens(),- ChatCompletionMaxTokensParameter::MaxCompletionTokens,- reasoning_effort,- config.model.interleaved_reasoning(),- ) {- Ok(request) => request,- Err(error) => return async move { Err(error.into()) }.boxed(),- };- let stream = self.stream_openai_chat(- &config,- subscription,- &request_limiter,- openai_request,- http_client,- extra_headers,- cx,- );- let executor = cx.background_executor().clone();- async move {- let mapper = ChatCompletionEventMapper::new();- Ok(language_model::stream_in_background(- mapper.map_stream(stream.await?).boxed(),- executor,- ))- }- .boxed()- }- ApiProtocol::OpenAiResponses => {- let supports_none_reasoning_effort = config- .model- .supported_reasoning_effort_levels()- .is_some_and(|levels| levels.contains(&ReasoningEffort::None));- let response_request = match into_open_ai_response(- request,- config.model.id(),- true,- false,- config.model.max_output_tokens(),- None,- supports_none_reasoning_effort,- &PROVIDER_ID,- ) {- Ok(request) => request,- Err(error) => return async move { Err(error.into()) }.boxed(),- };- let stream = self.stream_openai_response(- &config,- subscription,- &request_limiter,- response_request,- http_client,- extra_headers,- cx,- );- let executor = cx.background_executor().clone();- async move {- let mapper = OpenAiResponseEventMapper::new(PROVIDER_ID);- Ok(language_model::stream_in_background(- mapper.map_stream(stream.await?).boxed(),- executor,- ))- }- .boxed()- }- ApiProtocol::Google => {- let mut request = request;- if request.max_output_tokens.is_some() {- request.max_output_tokens =- request.effective_max_output_tokens(config.model.max_output_tokens());- }- let mode = if config.supports_thinking {- google_ai::GoogleModelMode::Thinking {- budget_tokens: None,- }- } else {- google_ai::GoogleModelMode::Default- };- let google_request = match into_google(request, config.model.id().to_string(), mode)- {- Ok(request) => request,- Err(error) => return async move { Err(error.into()) }.boxed(),- };- let stream = self.stream_google(- &config,- subscription,- &request_limiter,- google_request,- http_client,- extra_headers,- cx,- );- async move {- let mapper = GoogleEventMapper::new();- Ok(mapper.map_stream(stream.await?.boxed()).boxed())- }- .boxed()- }+ let api_url = self.base_api_url(&config, subscription, cx);+ let api_key = self.current_api_key(cx);+ let executor = cx.background_executor().clone();+ let stream_in_background = config.model.protocol() != ApiProtocol::Google;+ async move {+ let api_key = api_key.ok_or(LanguageModelCompletionError::NoApiKey {+ provider: PROVIDER_NAME,+ })?;+ let stream = request_limiter+ .stream(async move {+ opencode::completion::stream_completion(+ http_client.as_ref(),+ opencode::completion::CompletionConfig {+ model: &config,+ api_url: &api_url,+ api_key: &api_key,+ provider_id: PROVIDER_ID,+ provider_name: PROVIDER_NAME,+ custom_headers: &extra_headers,+ },+ request,+ )+ .await+ })+ .await?;+ Ok(if stream_in_background {+ language_model::stream_in_background(stream.boxed(), executor)+ } else {+ stream.boxed()+ })}+ .boxed()}}@@ -1015,161 +710,11 @@ fn language_model(model: &DiscoveredModel, subscription: OpenCodeSubscription) -}}-#[derive(Deserialize)]-struct RichCatalogProvider {- npm: Option<String>,- models: HashMap<String, RichCatalogModel>,-}--#[derive(Deserialize)]-struct RichCatalogModel {- id: String,- name: String,- #[serde(default)]- reasoning: bool,- #[serde(default)]- reasoning_options: Option<Vec<ReasoningOption>>,- #[serde(default)]- tool_call: bool,- #[serde(default)]- interleaved: serde_json::Value,- #[serde(default)]- modalities: ModelModalities,- limit: ModelLimits,- provider: Option<ModelTransport>,- cost: Option<ModelCost>,- status: Option<String>,-}--#[derive(Deserialize)]-struct ModelCost {- input: Option<f64>,- output: Option<f64>,-}--#[derive(Default, Deserialize)]-struct ModelModalities {- #[serde(default)]- input: Vec<String>,- #[serde(default)]- output: Vec<String>,-}--#[derive(Deserialize)]-struct ModelLimits {- context: u64,- output: Option<u64>,-}--#[derive(Deserialize)]-struct ModelTransport {- npm: Option<String>,-}--#[derive(Deserialize)]-struct ReasoningOption {- #[serde(rename = "type")]- kind: String,- #[serde(default)]- values: Vec<String>,-}-fn parse_discovered_models(rich_catalog: &str,subscription: OpenCodeSubscription,) -> Result<Vec<DiscoveredModel>> {- let provider_key = match subscription {- OpenCodeSubscription::Zen => "opencode",- OpenCodeSubscription::Go => "opencode-go",- };- let rich_catalog = serde_json::from_str::<serde_json::Value>(rich_catalog)?;- let provider = rich_catalog- .get(provider_key)- .cloned()- .ok_or_else(|| anyhow!("OpenCode catalog is missing {provider_key}"))?;- let provider = serde_json::from_value::<RichCatalogProvider>(provider)?;- let mut compatible_candidate_count = provider.models.len();- let models = provider- .models- .into_iter()- .filter_map(|(catalog_id, metadata)| {- if metadata.status.as_deref() == Some("deprecated")- || (subscription == OpenCodeSubscription::Zen- && metadata- .cost- .as_ref()- .is_some_and(|cost| cost.input == Some(0.0) && cost.output == Some(0.0)))- {- compatible_candidate_count -= 1;- return None;- }- if metadata.id != catalog_id- || !metadata.tool_call- || !metadata- .modalities- .output- .iter()- .any(|value| value == "text")- || metadata.limit.context == 0- {- return None;- }- let transport = metadata- .provider- .as_ref()- .and_then(|provider| provider.npm.as_deref())- .or(provider.npm.as_deref());- let protocol = transport.and_then(protocol_for_transport)?;- let reasoning_effort_levels = metadata- .reasoning- .then(|| {- metadata- .reasoning_options- .as_deref()- .unwrap_or_default()- .iter()- .find(|option| option.kind == "effort")- .into_iter()- .flat_map(|option| &option.values)- .filter_map(|effort| normalize_reasoning_effort(effort))- .collect::<Vec<_>>()- })- .filter(|levels| !levels.is_empty());- Some(DiscoveredModel {- model: opencode::Model::new(- metadata.id.clone(),- Some(metadata.name.clone()),- metadata.limit.context,- metadata.limit.output,- protocol,- reasoning_effort_levels,- None,- metadata.interleaved == serde_json::Value::Bool(true)- || metadata.interleaved.is_object(),- ),- supports_images: metadata- .modalities- .input- .iter()- .any(|value| value == "image"),- supports_thinking: metadata.reasoning,- })- })- .collect::<Vec<_>>();- if compatible_candidate_count > 0 && models.is_empty() {- bail!("OpenCode model metadata did not contain any compatible models");- }- Ok(models)-}--fn protocol_for_transport(transport: &str) -> Option<ApiProtocol> {- match transport {- "@ai-sdk/anthropic" => Some(ApiProtocol::Anthropic),- "@ai-sdk/openai" => Some(ApiProtocol::OpenAiResponses),- "@ai-sdk/openai-compatible" => Some(ApiProtocol::OpenAiChat),- "@ai-sdk/google" => Some(ApiProtocol::Google),- _ => None,- }+ opencode::catalog::parse_model_catalog(rich_catalog, subscription, None)}async fn fetch_model_catalog(diff --git a/crates/opencode/Cargo.toml b/crates/opencode/Cargo.tomlindex f2b5a0007d0..9ed942f672d 100644--- a/crates/opencode/Cargo.toml+++ b/crates/opencode/Cargo.toml@@ -10,7 +10,6 @@ workspace = true[lib]path = "src/opencode.rs"-test = falsedoctest = false[features]@@ -18,11 +17,17 @@ default = []schemars = ["dep:schemars"][dependencies]+anthropic.workspace = trueanyhow.workspace = truefutures.workspace = truegoogle_ai.workspace = truehttp_client.workspace = truelanguage_model_core.workspace = true+log.workspace = true+open_ai.workspace = trueschemars = { workspace = true, optional = true }serde.workspace = trueserde_json.workspace = true++[dev-dependencies]+http_client = { workspace = true, features = ["test-support"] }diff --git a/crates/opencode/src/catalog.rs b/crates/opencode/src/catalog.rsnew file mode 100644index 00000000000..a1772239f65--- /dev/null+++ b/crates/opencode/src/catalog.rs@@ -0,0 +1,204 @@+//! Model discovery shared by OpenCode clients.+//!+//! Applications own fetching and caching; this module applies the catalog's+//! subscription, capability, and transport rules consistently.++use anyhow::{Result, anyhow, bail};+use serde::Deserialize;+use std::collections::HashMap;++use crate::{ApiProtocol, Model, OpenCodeSubscription};+use language_model_core::ReasoningEffort;++pub const MODEL_CATALOG_URL: &str = "https://models.opencode.ai/api.json";++#[derive(Clone)]+pub struct DiscoveredModel {+ pub model: Model,+ pub supports_images: bool,+ pub supports_thinking: bool,+}++/// Parses compatible models, optionally restricted to a live endpoint's model IDs.+///+/// Deprecated models and zero-cost Zen models are excluded. An intentionally+/// filtered empty catalog is valid; unusable metadata is an error.+pub fn parse_model_catalog(+ catalog: &str,+ subscription: OpenCodeSubscription,+ available_models: Option<&[String]>,+) -> Result<Vec<DiscoveredModel>> {+ let provider_key = match subscription {+ OpenCodeSubscription::Zen => "opencode",+ OpenCodeSubscription::Go => "opencode-go",+ };+ let catalog = serde_json::from_str::<serde_json::Value>(catalog)?;+ let provider = catalog+ .get(provider_key)+ .ok_or_else(|| anyhow!("OpenCode catalog is missing {provider_key}"))?;+ let provider = serde_json::from_value::<CatalogProvider>(provider.clone())?;+ let model_ids = available_models.map_or_else(+ || {+ let mut ids = provider.models.keys().cloned().collect::<Vec<_>>();+ ids.sort();+ ids+ },+ |models| models.to_vec(),+ );+ let mut compatible_candidate_count = model_ids.len();+ let models = model_ids+ .into_iter()+ .filter_map(|model_id| {+ let metadata = provider.models.get(&model_id)?;+ let metadata = match CatalogModel::deserialize(metadata) {+ Ok(metadata) => metadata,+ Err(error) => {+ log::warn!("Invalid OpenCode metadata for {model_id}: {error}");+ return None;+ }+ };+ if metadata.status.as_deref() == Some("deprecated")+ || (subscription == OpenCodeSubscription::Zen+ && metadata+ .cost+ .as_ref()+ .is_some_and(|cost| cost.input == Some(0.0) && cost.output == Some(0.0)))+ {+ compatible_candidate_count -= 1;+ return None;+ }+ if metadata.id != model_id+ || !metadata.tool_call+ || !metadata+ .modalities+ .output+ .iter()+ .any(|value| value == "text")+ || metadata.limit.context == 0+ {+ return None;+ }+ let transport = metadata+ .provider+ .as_ref()+ .and_then(|provider| provider.npm.as_deref())+ .or(provider.npm.as_deref());+ let protocol = match transport? {+ "@ai-sdk/anthropic" => ApiProtocol::Anthropic,+ "@ai-sdk/openai" => ApiProtocol::OpenAiResponses,+ "@ai-sdk/openai-compatible" => ApiProtocol::OpenAiChat,+ "@ai-sdk/google" => ApiProtocol::Google,+ _ => return None,+ };+ let reasoning_effort_levels = metadata+ .reasoning+ .then(|| {+ metadata+ .reasoning_options+ .as_deref()+ .unwrap_or_default()+ .iter()+ .find(|option| option.kind == "effort")+ .into_iter()+ .flat_map(|option| &option.values)+ .filter_map(|effort| normalize_reasoning_effort(effort))+ .collect::<Vec<_>>()+ })+ .filter(|levels| !levels.is_empty());+ Some(DiscoveredModel {+ model: Model::new(+ metadata.id,+ Some(metadata.name),+ metadata.limit.context,+ metadata.limit.output,+ protocol,+ reasoning_effort_levels,+ None,+ metadata.interleaved == serde_json::Value::Bool(true)+ || metadata.interleaved.is_object(),+ ),+ supports_images: metadata+ .modalities+ .input+ .iter()+ .any(|value| value == "image"),+ supports_thinking: metadata.reasoning,+ })+ })+ .collect::<Vec<_>>();+ if compatible_candidate_count > 0 && models.is_empty() {+ bail!("OpenCode model metadata did not contain any compatible models");+ }+ Ok(models)+}++pub fn normalize_reasoning_effort(effort: &str) -> Option<ReasoningEffort> {+ match effort.trim().to_ascii_lowercase().as_str() {+ "none" => Some(ReasoningEffort::None),+ "minimal" => Some(ReasoningEffort::Minimal),+ "low" => Some(ReasoningEffort::Low),+ "medium" => Some(ReasoningEffort::Medium),+ "high" => Some(ReasoningEffort::High),+ "xhigh" => Some(ReasoningEffort::XHigh),+ "max" => Some(ReasoningEffort::Max),+ _ => None,+ }+}++#[derive(Deserialize)]+struct CatalogProvider {+ npm: Option<String>,+ models: HashMap<String, serde_json::Value>,+}++#[derive(Deserialize)]+struct CatalogModel {+ id: String,+ name: String,+ #[serde(default)]+ reasoning: bool,+ reasoning_options: Option<Vec<ReasoningOption>>,+ #[serde(default)]+ tool_call: bool,+ #[serde(default)]+ interleaved: serde_json::Value,+ #[serde(default)]+ modalities: ModelModalities,+ limit: ModelLimits,+ provider: Option<ModelTransport>,+ cost: Option<ModelCost>,+ status: Option<String>,+}++#[derive(Deserialize)]+struct ModelCost {+ input: Option<f64>,+ output: Option<f64>,+}++#[derive(Default, Deserialize)]+struct ModelModalities {+ #[serde(default)]+ input: Vec<String>,+ #[serde(default)]+ output: Vec<String>,+}++#[derive(Deserialize)]+struct ModelLimits {+ context: u64,+ output: Option<u64>,+}++#[derive(Deserialize)]+struct ModelTransport {+ npm: Option<String>,+}++#[derive(Deserialize)]+struct ReasoningOption {+ #[serde(rename = "type")]+ kind: String,+ #[serde(default)]+ values: Vec<String>,+}diff --git a/crates/opencode/src/completion.rs b/crates/opencode/src/completion.rsnew file mode 100644index 00000000000..da07d9da1f9--- /dev/null+++ b/crates/opencode/src/completion.rs@@ -0,0 +1,290 @@+//! 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 request = into_anthropic(+ request,+ model.id().to_string(),+ 1.0,+ model.max_output_tokens().unwrap_or(8192),+ mode,+ AnthropicPromptCacheMode::Automatic,+ &config.provider_id,+ )?;+ 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, path, response) in [+ (+ ApiProtocol::Anthropic,+ "/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,+ "/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,+ "/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,+ "/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");+ }+ Ok(Response::builder()+ .status(200)+ .body(AsyncBody::from(response))?)+ });+ let model = DiscoveredModel {+ model: crate::Model::new(+ "model".into(),+ None,+ 1000,+ Some(100),+ protocol,+ None,+ None,+ false,+ ),+ supports_images: false,+ supports_thinking: false,+ };+ let headers = CustomHeaders::new(vec![(+ http::HeaderName::from_static("x-custom"),+ http::HeaderValue::from_static("value"),+ )]);+ let request = LanguageModelRequest {+ 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(())+ }+}diff --git a/crates/opencode/src/opencode.rs b/crates/opencode/src/opencode.rsindex cfa3dcb34d5..0b995993a38 100644--- a/crates/opencode/src/opencode.rs+++ b/crates/opencode/src/opencode.rs@@ -11,6 +11,9 @@ use http_client::{use language_model_core::ReasoningEffort;use serde::{Deserialize, Serialize};+pub mod catalog;+pub mod completion;+pub const OPENCODE_API_URL: &str = "https://opencode.ai/zen";#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]