Summary: 479 instances, 276 unique

Text	Count
let fallback_path = format!("{home}/.lmstudio/bin/lms");	1
fn test_get_default_model_for_provider_lmstudio() {	1
let provider = ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None);	1
pub tools: Vec<ResponsesApiNamespaceTool>,	1
status: ollama_status.clone(),	1
use ModelProviderInfo as P;	1
let client = lmstudio_client.clone();	1
pub struct ModelProviderInfo {	1
impl From<Arc<RawValue>> for ResponsesApiTools {	1
ResponsesApiNamespaceTool::Function(tool) => {	1
ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None);	2
) -> Result<(String, ModelProviderInfo), ThreadConfigLoadError> {	1
LMSTUDIO_OSS_PROVIDER_ID => Some(codex_lmstudio::DEFAULT_OSS_MODEL),	1
status: ollama_status,	1
pub use responses_api::ResponsesApiNamespaceTool;	1
let ResponsesApiRequest {	2
ModelProviderInfo {	1
Ok(proto::WireApi::Unspecified) => {	1
ToolSpec::Namespace(ResponsesApiNamespace {	9
let model_providers = HashMap::<String, ModelProviderInfo>::deserialize(deserializer)?;	1
let base_url = "http://ollama-proxy.invalid";	1
mut model_providers: HashMap<String, ModelProviderInfo>,	1
tools: vec![ResponsesApiNamespaceTool::Function(ResponsesApiTool {	7
OLLAMA_OSS_PROVIDER_ID => Some(codex_ollama::DEFAULT_OSS_MODEL),	1
let mut request = ResponsesApiRequest {	1
use crate::ResponsesApiNamespaceTool;	3
let wire_api = match proto::WireApi::try_from(provider.wire_api) {	1
pub(crate) async fn provider(&self) -> ModelProviderInfo {	1
Request::new(Method::POST, "https://example.com/v1/responses".to_string())	2
let url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();	1
let provider = ModelProviderInfo {	1
impl WireApi {	1
Ok(ToolSpec::Namespace(ResponsesApiNamespace {	1
fn append_function_search_text(tool: &ResponsesApiTool, parts: &mut Vec<String>) {	1
pub use tool_spec::ResponsesApiWebSearchFilters;	1
use codex_responses_api_proxy::Args as ResponsesApiProxyArgs;	2
pub use tool_spec::ResponsesApiWebSearchUserLocation;	1
ResponsesApiNamespaceTool::Function(tool) => {	2
WireApi::Responses => proto::WireApi::Responses,	1
ModelProviderInfo::create_openai_provider(/*base_url*/ None),	9
ResponsesApiNamespaceTool::Custom(tool) => tool.name.as_str(),	1
ToolSpec::Function(ResponsesApiTool {	23
pub const OLLAMA_CHAT_PROVIDER_REMOVED_ERROR: &str = "`ollama-chat` is no longer supported.\nHow to fix: replace `ollama-chat` with `ollama` in `model_provider`, `oss_provider`, or `--local-provider`.\nMore info: https://github.com/openai/codex/discussions/7782";	1
use codex_model_provider_info::ModelProviderInfo;	21
let lmstudio_status = check_lmstudio_status(&client).await;	1
pub use responses_api::ResponsesApiNamespace;	1
ResponsesApiNamespaceTool::Custom(tool) => {	2
request: &ResponsesApiRequest,	2
pub const LEGACY_OLLAMA_CHAT_PROVIDER_ID: &str = "ollama-chat";	1
url: "https://example.com/openai/v1/responses?api-version=2026-01-01"	1
use crate::common::ResponsesApiRequest;	1
use crate::ResponsesApiNamespace;	2
provider_info: ModelProviderInfo,	3
let provider = ModelProviderInfo::create_openai_provider(/*base_url*/ None);	6
configured_model_providers: HashMap<String, ModelProviderInfo>,	1
Some(Subcommand::ResponsesApiProxy(_)) => Some("responses-api-proxy"),	1
let provider_info = ModelProviderInfo::create_amazon_bedrock_provider(Some(aws.clone()));	1
"codex-ollama-invalid-ca-{}.pem",	1
wire_api: WireApi::Responses,	1
use codex_model_provider_info::WireApi;	5
ResponsesApiNamespaceTool::Custom(tool) => tool.name == name.name,	1
let client = codex_ollama::OllamaClient::try_from_oss_provider(config).await?;	1
let ollama_client =	1
let ModelProviderInfo {	1
use crate::ResponsesApiTool;	2
.push(ResponsesApiNamespaceTool::Custom(tool.clone()));	1
url: "https://api.openai.com/v1/responses".to_string(),	1
provider_info: ModelProviderInfo,	2
let fallback_path = format!("{home}/.lmstudio/bin/lms.exe");	1
"LM Studio not found. Please install LM Studio from https://lmstudio.ai/",	1
model_provider: ModelProviderInfo,	1
ResponsesApiNamespaceTool::Function(tool) => {	1
ResponsesApiNamespaceTool::Function(tool) => tool.name.as_str(),	1
assert_eq!(result, Some(codex_lmstudio::DEFAULT_OSS_MODEL));	1
ResponsesApiNamespaceTool::Function(ResponsesApiTool {	2
provider: ModelProviderInfo,	3
ModelProviderInfo {	2
ResponsesApiNamespaceTool::Custom(tool) => {	1
"{} set; skipping version_check_reuses_existing_ollama_client",	1
let api_request = ResponsesApiRequest {	1
fn new(lmstudio_status: ProviderStatus, ollama_status: ProviderStatus) -> io::Result<Self> {	1
ollama_client	1
assert_eq!(overrides.model_provider.as_deref(), Some("ollama"));	1
pub model_provider: ModelProviderInfo,	1
status: lmstudio_status,	1
ResponsesApiNamespaceTool::Function(tool) => &tool.name,	2
pub model_providers: HashMap<String, ModelProviderInfo>,	3
use codex_tools::ResponsesApiTool;	1
/// The Responses API exposed by OpenAI at `/v1/responses`.	1
ResponsesApiNamespaceTool::Custom(tool)	1
"ollama",	1
impl<'a> From<&'a ResponsesApiRequest> for ResponseCreateWsRequest<'a> {	1
impl From<ConfigWebSearchUserLocation> for ResponsesApiWebSearchUserLocation {	1
) -> Result<ResponsesApiRequest> {	1
fn provider_info_with_command_auth() -> ModelProviderInfo {	2
let expected = ModelProviderInfo {	1
use codex_tools::ResponsesApiNamespace;	10
wire_api: proto::WireApi::Responses.into(),	1
lmstudio_status: ProviderStatus,	1
WireApi wire_api = 8;	1
const LMSTUDIO_CONNECTION_ERROR: &str = "LM Studio is not responding. Install from https://lmstudio.ai/download and run 'lms server start'.";	1
ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None),	7
fn realtime_api_key(auth: Option<&CodexAuth>, provider: &ModelProviderInfo) -> CodexResult<String> {	1
pub struct ResponsesApiTool {	1
Some(Subcommand::ResponsesApiProxy(args)) => {	1
provider: ModelProviderInfo,	3
ollama_status,	1
let api_url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();	1
lmstudio_client.download_model(model).await?;	1
pub struct ResponsesApiWebSearchFilters {	1
/// Runtime model provider backed by configured `ModelProviderInfo`.	1
ToolSpec::Function(tool) => ToolSpec::Namespace(ResponsesApiNamespace {	1
fn new(provider_info: ModelProviderInfo, auth_manager: Option<Arc<AuthManager>>) -> Self {	1
Function(ResponsesApiTool),	3
const OLLAMA_CONNECTION_ERROR: &str = "No running Ollama server detected. Start it with: `ollama serve` (after installing). Install instructions: https://github.com/ollama/ollama?tab=readme-ov-file#ollama";	1
pub const LMSTUDIO_OSS_PROVIDER_ID: &str = "lmstudio";	1
tools: vec![ResponsesApiNamespaceTool::Custom(tool)],	1
PATH = "/v1/responses"	1
tools: vec![ResponsesApiNamespaceTool::Function(ResponsesApiTool {	2
lmstudio_status,	1
use codex_tools::ResponsesApiTool;	17
/// Preferred OSS provider for local models, e.g. "lmstudio" or "ollama".	1
tools: vec![ResponsesApiNamespaceTool::Function(ResponsesApiTool {	1
let tool = ResponsesApiTool {	2
if config.model_provider.wire_api == WireApi::Responses {	1
pub fn tool_definition_to_responses_api_tool(tool_definition: ToolDefinition) -> ResponsesApiTool {	1
let mut provider = ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None);	1
ollama_status,	1
WireApi::Responses => {	1
ResponsesApiNamespaceTool::Custom(tool) => &tool.name,	2
let provider = create_oss_provider_with_base_url(base_url, WireApi::Responses);	2
ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None);	1
let lmstudio_client = LMStudioClient::try_from_provider(config).await?;	1
) -> HashMap<String, ModelProviderInfo> {	1
fn test_get_default_model_for_provider_ollama() {	1
pub fn create_oss_provider_with_base_url(base_url: &str, wire_api: WireApi) -> ModelProviderInfo {	1
wire_api: WireApi::Responses,	6
#[prost(enumeration = "WireApi", tag = "8")]	1
current: &ResponsesApiRequest,	1
ModelProviderInfo {	1
ResponsesApiProxy(ResponsesApiProxyArgs),	1
fn from(request: &'a ResponsesApiRequest) -> Self {	1
pub enum WireApi {	2
ToolSpec::Namespace(ResponsesApiNamespace {	2
user_location: Option<ResponsesApiWebSearchUserLocation>,	1
ollama_status: ProviderStatus,	1
let mut provider_info = ModelProviderInfo::create_openai_provider(Some(server.uri()));	1
tools: vec![ResponsesApiNamespaceTool::Function(tool)],	3
if config.model_provider.wire_api == WireApi::Responses {	1
pub use responses_api::ResponsesApiTool;	1
fn info(&self) -> &ModelProviderInfo;	1
"/v1/responses",	1
filters: Option<ResponsesApiWebSearchFilters>,	1
ToolSpec::Function(ResponsesApiTool {	4
pub fn create_openai_provider(base_url: Option<String>) -> ModelProviderInfo {	1
fn test_provider(name: &str) -> ModelProviderInfo {	1
let ResponsesApiNamespaceTool::Function(function) = &spec.tools[0] else {	1
..ModelProviderInfo::default()	2
enum WireApi {	1
ResponsesApiNamespaceTool::Custom(tool) => {	1
url: "https://bedrock-runtime.us-east-1.amazonaws.com/v1/responses".to_string(),	1
ModelProviderInfo::create_openai_provider(/*base_url*/ None),	1
pub use crate::common::ResponsesApiRequest;	1
codex_ollama::ensure_oss_ready(config, &client)	1
codex_lmstudio::ensure_oss_ready(config)	1
create_oss_provider(DEFAULT_OLLAMA_PORT, WireApi::Responses),	1
ModelProviderInfo::create_amazon_bedrock_provider(Some(ModelProviderAwsAuthInfo {	1
) -> Result<HashMap<String, ModelProviderInfo>, String> {	1
let mut widget = OssSelectionWidget::new(lmstudio_status, ollama_status)?;	1
request: ResponsesApiRequest,	1
ModelProviderInfo::create_amazon_bedrock_provider(Some(invalid_aws)),	1
#[arg(long, default_value = "https://api.openai.com/v1/responses")]	1
) -> Result<HashMap<String, ModelProviderInfo>, D::Error>	1
tools: vec![ResponsesApiNamespaceTool::Function(output_tool)],	1
impl PartialEq for ResponsesApiTools {	1
assert_eq!(result, Some(codex_ollama::DEFAULT_OSS_MODEL));	1
pub struct ResponsesApiTools(Arc<RawValue>);	1
pub wire_api: WireApi,	1
ModelProviderInfo::create_amazon_bedrock_provider(Some(ModelProviderAwsAuthInfo {	2
provider_info: &ModelProviderInfo,	1
pub const OLLAMA_OSS_PROVIDER_ID: &str = "ollama";	1
let request = ResponsesApiRequest {	1
async fn check_ollama_status(client: &HttpClient) -> ProviderStatus {	1
fn proto_wire_api(wire_api: WireApi) -> proto::WireApi {	1
pub use crate::common::ResponsesApiTools;	1
ResponsesApiNamespaceTool::Function(tool) => tool.name == name.name,	1
use codex_model_provider_info::ModelProviderInfo;	3
create_oss_provider(DEFAULT_LMSTUDIO_PORT, WireApi::Responses),	1
use codex_extension_api::ResponsesApiTool;	3
ollama_status: ProviderStatus,	1
url: Some("https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses".to_string()),	1
impl ResponsesApiTools {	1
use codex_api::ResponsesApiRequest;	2
/// `ModelProviderInfo` returned by `info` is the serialized/configured provider	1
impl ModelProviderInfo {	1
Ok(proto::WireApi::Responses) => WireApi::Responses,	1
codex_tools::ToolSpec::Function(codex_tools::ResponsesApiTool {	3
/// [`ModelProviderInfo`] to use.	1
tools: vec![ResponsesApiNamespaceTool::Function(tool)],	1
impl<'de> Deserialize<'de> for WireApi {	1
) -> Result<ResponsesApiTool, serde_json::Error> {	4
LoadableToolSpec::Namespace(ResponsesApiNamespace {	4
last_request: Option<ResponsesApiRequest>,	1
ModelProviderInfo::create_amazon_bedrock_runtime_provider(/*aws*/ None),	3
// Only allow POST /v1/responses exactly, no query string.	1
lmstudio_status: ProviderStatus,	1
let mut functions = ResponsesApiNamespace {	1
impl Serialize for ResponsesApiTools {	1
ModelProviderInfo::create_amazon_bedrock_provider(Some(ModelProviderAwsAuthInfo {	1
let args = ResponsesApiProxyArgs::parse();	1
use codex_model_provider_info::WireApi;	6
ResponsesApiTool {	1
.dump_request(&Method::Post, "/v1/responses", &[], b"{}")	1
if provider != ModelProviderInfo::default() {	1
fn provider_for(base_url: String) -> ModelProviderInfo {	1
ModelProviderInfo::create_amazon_bedrock_provider(Some(aws.clone())),	1
let ollama_status = check_ollama_status(&client).await;	1
use codex_tools::ResponsesApiNamespaceTool;	1
pub fn create_oss_provider(default_provider_port: u16, wire_api: WireApi) -> ModelProviderInfo {	1
oss_selection::select_oss_provider(lmstudio_status, ollama_status)	1
.push(ResponsesApiNamespaceTool::Function(tool.clone()));	1
#[schemars(rename = "ResponsesApiWebSearchAction")]	1
fn command_auth_provider(base_url: Option<&str>) -> ModelProviderInfo {	1
request: &ResponsesApiRequest,	1
..ModelProviderInfo::create_openai_provider(/*base_url*/ None)	2
impl fmt::Display for WireApi {	1
ModelProviderInfo {	7
lmstudio_status,	1
provider: &ModelProviderInfo,	5
create_oss_provider_with_base_url("http://localhost:11434/v1", WireApi::Responses);	5
let provider = create_oss_provider_with_base_url(&server.uri(), WireApi::Responses);	2
..ModelProviderInfo::default()	1
async fn check_lmstudio_status(client: &HttpClient) -> ProviderStatus {	1
use codex_tools::ResponsesApiNamespaceTool;	14
provider: &ModelProviderInfo,	1
tools: request.tools.as_ref().map(ResponsesApiTools::as_raw_value),	1
create_oss_provider_with_base_url("http://localhost:11434/v1", WireApi::Responses),	1
url: "https://example.openai.azure.com/openai/v1/responses".to_string(),	1
pub struct ResponsesApiWebSearchUserLocation {	1
tools: vec![ResponsesApiNamespaceTool::Function(tool)],	1
use codex_tools::ResponsesApiNamespace;	1
pub enum ResponsesApiNamespaceTool {	1
fn provider_uses_first_party_auth_path(provider: &ModelProviderInfo) -> bool {	1
// Empirically, ollama returns a 200 OK response even when	1
let allow = method == Method::Post && url_path == "/v1/responses";	1
async fn resolve_runtime_model_provider_base_url(provider: &ModelProviderInfo) -> Option<String> {	1
pub struct ResponsesApiNamespace {	1
pub struct ResponsesApiRequest {	1
impl From<ConfigWebSearchFilters> for ResponsesApiWebSearchFilters {	1
info: ModelProviderInfo,	1
ToolSpec::Function(ResponsesApiTool {	2
pub(crate) info: ModelProviderInfo,	1
let info = ModelProviderInfo {	1
let request = Request::new(Method::POST, "https://example.com/v1/responses".to_string())	1
previous: &ResponsesApiRequest,	1
"url": "/v1/responses",	1
pub tools: Option<ResponsesApiTools>,	2
&ModelProviderInfo,	1
) -> ModelProviderInfo {	2
use crate::common::ResponsesApiRequest;	1
config.model_provider = ModelProviderInfo {	1
"https://bedrock-runtime.us-east-1.amazonaws.com/v1/responses"	1
Namespace(ResponsesApiNamespace),	2
let ResponsesApiRequest {	1
match lmstudio_client.fetch_models().await {	1
model_providers: &HashMap<String, ModelProviderInfo>,	2
fn expected_provider() -> ModelProviderInfo {	1
Some(namespace) => ToolSpec::Namespace(ResponsesApiNamespace {	1
provider: ModelProviderInfo::create_openai_provider(/*base_url*/ None),	1
async fn version_check_reuses_existing_ollama_client() {	1
fn info(&self) -> &ModelProviderInfo {	2
codex_ollama::ensure_responses_supported(&client).await?;	1
provider_info: ModelProviderInfo::create_openai_provider(Some(server.uri())),	1
/// Specify which local provider to use (lmstudio or ollama).	1
pub use codex_tools::ResponsesApiTool;	1
match (&lmstudio_status, &ollama_status) {	1
