use crate::completion::CompletionRequest;
use crate::json_utils::Lenient;
use crate::model::{ModelInfo, ModelList};
use crate::providers::internal::credential_header;
use crate::providers::openai::responses_api::SystemInstructionsPlacement;
use crate::providers::openai::wire::{
Dialect, DialectHooks, EmbeddingQuirks, OpenAIConfig, Quirks, ResponsesQuirks, Route,
};
use crate::wire::Body;
use serde_json::Value;
use super::PROVIDER_NAME;
pub(super) const REQUEST_ID_HEADER: Option<&str> = Some("x-request-id");
pub const DIALECT: Dialect = Dialect {
base_url_env: Some("GITHUB_COPILOT_API_BASE"),
request_id_header: REQUEST_ID_HEADER,
quirks: Quirks {
hooks: Some(&HOOKS),
verify_path: "",
catalog_priced: false,
base_url_env_alias: Some("COPILOT_BASE_URL"),
accepts_file_ids: false,
short_lived_key: true,
routes_by_catalog: true,
embedding: EmbeddingQuirks {
requires_usage: false,
..EmbeddingQuirks::openai()
},
responses: ResponsesQuirks {
strict_tools_by_default: true,
system_instructions: SystemInstructionsPlacement::InputSystemMessages,
..ResponsesQuirks::openai()
},
..Quirks::openai()
},
..Dialect::gateway(
PROVIDER_NAME,
super::GITHUB_COPILOT_API_BASE_URL,
"GITHUB_COPILOT_API_KEY",
)
};
static HOOKS: DialectHooks = DialectHooks {
default_endpoint: Some(super::auth::base_url_from_token),
model_route: Some(|model| {
if routes_through_responses(model) {
Route::Responses
} else {
Route::Chat
}
}),
completion_envelope: Some(completion_envelope),
modality_envelope: Some(|provider, request| {
stamp(request, provider.api_key.expose(), "user", false)
}),
model_listing: Some(catalogue),
};
fn catalogue(event: Value) -> ModelList {
let text =
|entry: &Value, pointer: &str| entry.at(pointer).and_then(Value::as_str).map(str::to_owned);
let models = event
.arr("data")
.iter()
.filter_map(|entry| {
let mut model = ModelInfo::from_id(entry.str("id")?);
model.name = text(entry, "/name");
model.owned_by = text(entry, "/vendor");
model.r#type = text(entry, "/capabilities/type");
model.supports_tool_calls = entry
.at("/capabilities/supports/tool_calls")
.and_then(Value::as_bool);
Some(model)
})
.collect();
ModelList::new(models)
}
fn completion_envelope(
provider: &OpenAIConfig,
request: &CompletionRequest,
mut builder: http::request::Builder,
) -> http::request::Builder {
for (name, value) in super::default_headers(
provider.api_key.expose(),
super::request_initiator(request),
super::request_has_vision(request),
) {
if let Some(headers) = builder.headers_mut() {
headers.remove(name);
}
builder = if name == http::header::AUTHORIZATION {
credential_header(builder, name, &value)
} else {
builder.header(name, value)
};
}
builder
}
pub fn routes_through_responses(model: &str) -> bool {
model.to_ascii_lowercase().contains("codex")
}
pub(super) fn stamp(
request: &mut http::Request<Body>,
api_key: &str,
initiator: &'static str,
has_vision: bool,
) -> Result<(), http::Error> {
let map = request.headers_mut();
for (name, value) in super::default_headers(api_key, initiator, has_vision) {
let name = http::HeaderName::from_bytes(name.as_bytes())?;
let mut value = http::HeaderValue::from_str(&value)?;
value.set_sensitive(name == http::header::AUTHORIZATION);
map.insert(name, value);
}
Ok(())
}
#[cfg(test)]
mod tests;