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.

opencode: Share catalog parsing and completion dispatch (#65922)

Bennet Bo Fenner41e9dc5837f7
diff --git a/Cargo.lock b/Cargo.lock
index 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.rs
index 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.toml
index 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 = false
doctest = false
[features]
@@ -18,11 +17,17 @@ default = []
schemars = ["dep:schemars"]
[dependencies]
+anthropic.workspace = true
anyhow.workspace = true
futures.workspace = true
google_ai.workspace = true
http_client.workspace = true
language_model_core.workspace = true
+log.workspace = true
+open_ai.workspace = true
schemars = { workspace = true, optional = true }
serde.workspace = true
serde_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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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)]