1use anyhow::{Result, anyhow};
   2use collections::{BTreeMap, HashMap};
   3use futures::Stream;
   4use futures::{FutureExt, StreamExt, future::BoxFuture};
   5use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window};
   6use http_client::HttpClient;
   7use language_model::{
   8    ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError,
   9    LanguageModelCompletionEvent, LanguageModelId, LanguageModelImage, LanguageModelName,
  10    LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,
  11    LanguageModelProviderState, LanguageModelRequest, LanguageModelRequestMessage,
  12    LanguageModelToolChoice, LanguageModelToolResult, LanguageModelToolResultContent,
  13    LanguageModelToolUse, LanguageModelToolUseId, MessageContent, RateLimiter, Role, StopReason,
  14    TokenUsage, env_var,
  15};
  16use menu;
  17use open_ai::responses::{
  18    ResponseFunctionCallItem, ResponseFunctionCallOutputItem, ResponseInputContent,
  19    ResponseInputItem, ResponseMessageItem,
  20};
  21use open_ai::{
  22    ImageUrl, Model, OPEN_AI_API_URL, ReasoningEffort, ResponseStreamEvent,
  23    responses::{
  24        Request as ResponseRequest, ResponseOutputItem, ResponseSummary as ResponsesSummary,
  25        ResponseUsage as ResponsesUsage, StreamEvent as ResponsesStreamEvent, stream_response,
  26    },
  27    stream_completion,
  28};
  29use settings::{OpenAiAvailableModel as AvailableModel, Settings, SettingsStore};
  30use std::pin::Pin;
  31use std::sync::{Arc, LazyLock};
  32use strum::IntoEnumIterator;
  33use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*};
  34use ui_input::InputField;
  35use util::ResultExt;
  36
  37use crate::provider::util::parse_tool_arguments;
  38
  39const PROVIDER_ID: LanguageModelProviderId = language_model::OPEN_AI_PROVIDER_ID;
  40const PROVIDER_NAME: LanguageModelProviderName = language_model::OPEN_AI_PROVIDER_NAME;
  41
  42const API_KEY_ENV_VAR_NAME: &str = "OPENAI_API_KEY";
  43static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
  44
  45#[derive(Default, Clone, Debug, PartialEq)]
  46pub struct OpenAiSettings {
  47    pub api_url: String,
  48    pub available_models: Vec<AvailableModel>,
  49}
  50
  51pub struct OpenAiLanguageModelProvider {
  52    http_client: Arc<dyn HttpClient>,
  53    state: Entity<State>,
  54}
  55
  56pub struct State {
  57    api_key_state: ApiKeyState,
  58}
  59
  60impl State {
  61    fn is_authenticated(&self) -> bool {
  62        self.api_key_state.has_key()
  63    }
  64
  65    fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {
  66        let api_url = OpenAiLanguageModelProvider::api_url(cx);
  67        self.api_key_state
  68            .store(api_url, api_key, |this| &mut this.api_key_state, cx)
  69    }
  70
  71    fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
  72        let api_url = OpenAiLanguageModelProvider::api_url(cx);
  73        self.api_key_state
  74            .load_if_needed(api_url, |this| &mut this.api_key_state, cx)
  75    }
  76}
  77
  78impl OpenAiLanguageModelProvider {
  79    pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
  80        let state = cx.new(|cx| {
  81            cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
  82                let api_url = Self::api_url(cx);
  83                this.api_key_state
  84                    .handle_url_change(api_url, |this| &mut this.api_key_state, cx);
  85                cx.notify();
  86            })
  87            .detach();
  88            State {
  89                api_key_state: ApiKeyState::new(Self::api_url(cx), (*API_KEY_ENV_VAR).clone()),
  90            }
  91        });
  92
  93        Self { http_client, state }
  94    }
  95
  96    fn create_language_model(&self, model: open_ai::Model) -> Arc<dyn LanguageModel> {
  97        Arc::new(OpenAiLanguageModel {
  98            id: LanguageModelId::from(model.id().to_string()),
  99            model,
 100            state: self.state.clone(),
 101            http_client: self.http_client.clone(),
 102            request_limiter: RateLimiter::new(4),
 103        })
 104    }
 105
 106    fn settings(cx: &App) -> &OpenAiSettings {
 107        &crate::AllLanguageModelSettings::get_global(cx).openai
 108    }
 109
 110    fn api_url(cx: &App) -> SharedString {
 111        let api_url = &Self::settings(cx).api_url;
 112        if api_url.is_empty() {
 113            open_ai::OPEN_AI_API_URL.into()
 114        } else {
 115            SharedString::new(api_url.as_str())
 116        }
 117    }
 118}
 119
 120impl LanguageModelProviderState for OpenAiLanguageModelProvider {
 121    type ObservableEntity = State;
 122
 123    fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
 124        Some(self.state.clone())
 125    }
 126}
 127
 128impl LanguageModelProvider for OpenAiLanguageModelProvider {
 129    fn id(&self) -> LanguageModelProviderId {
 130        PROVIDER_ID
 131    }
 132
 133    fn name(&self) -> LanguageModelProviderName {
 134        PROVIDER_NAME
 135    }
 136
 137    fn icon(&self) -> IconOrSvg {
 138        IconOrSvg::Icon(IconName::AiOpenAi)
 139    }
 140
 141    fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
 142        Some(self.create_language_model(open_ai::Model::default()))
 143    }
 144
 145    fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
 146        Some(self.create_language_model(open_ai::Model::default_fast()))
 147    }
 148
 149    fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
 150        let mut models = BTreeMap::default();
 151
 152        // Add base models from open_ai::Model::iter()
 153        for model in open_ai::Model::iter() {
 154            if !matches!(model, open_ai::Model::Custom { .. }) {
 155                models.insert(model.id().to_string(), model);
 156            }
 157        }
 158
 159        // Override with available models from settings
 160        for model in &OpenAiLanguageModelProvider::settings(cx).available_models {
 161            models.insert(
 162                model.name.clone(),
 163                open_ai::Model::Custom {
 164                    name: model.name.clone(),
 165                    display_name: model.display_name.clone(),
 166                    max_tokens: model.max_tokens,
 167                    max_output_tokens: model.max_output_tokens,
 168                    max_completion_tokens: model.max_completion_tokens,
 169                    reasoning_effort: model.reasoning_effort.clone(),
 170                    supports_chat_completions: model.capabilities.chat_completions,
 171                },
 172            );
 173        }
 174
 175        models
 176            .into_values()
 177            .map(|model| self.create_language_model(model))
 178            .collect()
 179    }
 180
 181    fn is_authenticated(&self, cx: &App) -> bool {
 182        self.state.read(cx).is_authenticated()
 183    }
 184
 185    fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
 186        self.state.update(cx, |state, cx| state.authenticate(cx))
 187    }
 188
 189    fn configuration_view(
 190        &self,
 191        _target_agent: language_model::ConfigurationViewTargetAgent,
 192        window: &mut Window,
 193        cx: &mut App,
 194    ) -> AnyView {
 195        cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx))
 196            .into()
 197    }
 198
 199    fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {
 200        self.state
 201            .update(cx, |state, cx| state.set_api_key(None, cx))
 202    }
 203}
 204
 205pub struct OpenAiLanguageModel {
 206    id: LanguageModelId,
 207    model: open_ai::Model,
 208    state: Entity<State>,
 209    http_client: Arc<dyn HttpClient>,
 210    request_limiter: RateLimiter,
 211}
 212
 213impl OpenAiLanguageModel {
 214    fn stream_completion(
 215        &self,
 216        request: open_ai::Request,
 217        cx: &AsyncApp,
 218    ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponseStreamEvent>>>>
 219    {
 220        let http_client = self.http_client.clone();
 221
 222        let (api_key, api_url) = self.state.read_with(cx, |state, cx| {
 223            let api_url = OpenAiLanguageModelProvider::api_url(cx);
 224            (state.api_key_state.key(&api_url), api_url)
 225        });
 226
 227        let future = self.request_limiter.stream(async move {
 228            let provider = PROVIDER_NAME;
 229            let Some(api_key) = api_key else {
 230                return Err(LanguageModelCompletionError::NoApiKey { provider });
 231            };
 232            let request = stream_completion(
 233                http_client.as_ref(),
 234                provider.0.as_str(),
 235                &api_url,
 236                &api_key,
 237                request,
 238            );
 239            let response = request.await?;
 240            Ok(response)
 241        });
 242
 243        async move { Ok(future.await?.boxed()) }.boxed()
 244    }
 245
 246    fn stream_response(
 247        &self,
 248        request: ResponseRequest,
 249        cx: &AsyncApp,
 250    ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponsesStreamEvent>>>>
 251    {
 252        let http_client = self.http_client.clone();
 253
 254        let (api_key, api_url) = self.state.read_with(cx, |state, cx| {
 255            let api_url = OpenAiLanguageModelProvider::api_url(cx);
 256            (state.api_key_state.key(&api_url), api_url)
 257        });
 258
 259        let provider = PROVIDER_NAME;
 260        let future = self.request_limiter.stream(async move {
 261            let Some(api_key) = api_key else {
 262                return Err(LanguageModelCompletionError::NoApiKey { provider });
 263            };
 264            let request = stream_response(
 265                http_client.as_ref(),
 266                provider.0.as_str(),
 267                &api_url,
 268                &api_key,
 269                request,
 270            );
 271            let response = request.await?;
 272            Ok(response)
 273        });
 274
 275        async move { Ok(future.await?.boxed()) }.boxed()
 276    }
 277}
 278
 279impl LanguageModel for OpenAiLanguageModel {
 280    fn id(&self) -> LanguageModelId {
 281        self.id.clone()
 282    }
 283
 284    fn name(&self) -> LanguageModelName {
 285        LanguageModelName::from(self.model.display_name().to_string())
 286    }
 287
 288    fn provider_id(&self) -> LanguageModelProviderId {
 289        PROVIDER_ID
 290    }
 291
 292    fn provider_name(&self) -> LanguageModelProviderName {
 293        PROVIDER_NAME
 294    }
 295
 296    fn supports_tools(&self) -> bool {
 297        true
 298    }
 299
 300    fn supports_images(&self) -> bool {
 301        use open_ai::Model;
 302        match &self.model {
 303            Model::FourOmniMini
 304            | Model::FourPointOneNano
 305            | Model::Five
 306            | Model::FiveCodex
 307            | Model::FiveMini
 308            | Model::FiveNano
 309            | Model::FivePointOne
 310            | Model::FivePointTwo
 311            | Model::FivePointTwoCodex
 312            | Model::FivePointThreeCodex
 313            | Model::FivePointFour
 314            | Model::FivePointFourPro
 315            | Model::O1
 316            | Model::O3 => true,
 317            Model::ThreePointFiveTurbo
 318            | Model::Four
 319            | Model::FourTurbo
 320            | Model::O3Mini
 321            | Model::Custom { .. } => false,
 322        }
 323    }
 324
 325    fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {
 326        match choice {
 327            LanguageModelToolChoice::Auto => true,
 328            LanguageModelToolChoice::Any => true,
 329            LanguageModelToolChoice::None => true,
 330        }
 331    }
 332
 333    fn supports_streaming_tools(&self) -> bool {
 334        true
 335    }
 336
 337    fn supports_thinking(&self) -> bool {
 338        self.model.reasoning_effort().is_some()
 339    }
 340
 341    fn supports_split_token_display(&self) -> bool {
 342        true
 343    }
 344
 345    fn telemetry_id(&self) -> String {
 346        format!("openai/{}", self.model.id())
 347    }
 348
 349    fn max_token_count(&self) -> u64 {
 350        self.model.max_token_count()
 351    }
 352
 353    fn max_output_tokens(&self) -> Option<u64> {
 354        self.model.max_output_tokens()
 355    }
 356
 357    fn count_tokens(
 358        &self,
 359        request: LanguageModelRequest,
 360        cx: &App,
 361    ) -> BoxFuture<'static, Result<u64>> {
 362        count_open_ai_tokens(request, self.model.clone(), cx)
 363    }
 364
 365    fn stream_completion(
 366        &self,
 367        request: LanguageModelRequest,
 368        cx: &AsyncApp,
 369    ) -> BoxFuture<
 370        'static,
 371        Result<
 372            futures::stream::BoxStream<
 373                'static,
 374                Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
 375            >,
 376            LanguageModelCompletionError,
 377        >,
 378    > {
 379        if self.model.supports_chat_completions() {
 380            let request = into_open_ai(
 381                request,
 382                self.model.id(),
 383                self.model.supports_parallel_tool_calls(),
 384                self.model.supports_prompt_cache_key(),
 385                self.max_output_tokens(),
 386                self.model.reasoning_effort(),
 387            );
 388            let completions = self.stream_completion(request, cx);
 389            async move {
 390                let mapper = OpenAiEventMapper::new();
 391                Ok(mapper.map_stream(completions.await?).boxed())
 392            }
 393            .boxed()
 394        } else {
 395            let request = into_open_ai_response(
 396                request,
 397                self.model.id(),
 398                self.model.supports_parallel_tool_calls(),
 399                self.model.supports_prompt_cache_key(),
 400                self.max_output_tokens(),
 401                self.model.reasoning_effort(),
 402            );
 403            let completions = self.stream_response(request, cx);
 404            async move {
 405                let mapper = OpenAiResponseEventMapper::new();
 406                Ok(mapper.map_stream(completions.await?).boxed())
 407            }
 408            .boxed()
 409        }
 410    }
 411}
 412
 413pub fn into_open_ai(
 414    request: LanguageModelRequest,
 415    model_id: &str,
 416    supports_parallel_tool_calls: bool,
 417    supports_prompt_cache_key: bool,
 418    max_output_tokens: Option<u64>,
 419    reasoning_effort: Option<ReasoningEffort>,
 420) -> open_ai::Request {
 421    let stream = !model_id.starts_with("o1-");
 422
 423    let mut messages = Vec::new();
 424    for message in request.messages {
 425        for content in message.content {
 426            match content {
 427                MessageContent::Text(text) | MessageContent::Thinking { text, .. } => {
 428                    let should_add = if message.role == Role::User {
 429                        // Including whitespace-only user messages can cause error with OpenAI compatible APIs
 430                        // See https://github.com/zed-industries/zed/issues/40097
 431                        !text.trim().is_empty()
 432                    } else {
 433                        !text.is_empty()
 434                    };
 435                    if should_add {
 436                        add_message_content_part(
 437                            open_ai::MessagePart::Text { text },
 438                            message.role,
 439                            &mut messages,
 440                        );
 441                    }
 442                }
 443                MessageContent::RedactedThinking(_) => {}
 444                MessageContent::Image(image) => {
 445                    add_message_content_part(
 446                        open_ai::MessagePart::Image {
 447                            image_url: ImageUrl {
 448                                url: image.to_base64_url(),
 449                                detail: None,
 450                            },
 451                        },
 452                        message.role,
 453                        &mut messages,
 454                    );
 455                }
 456                MessageContent::ToolUse(tool_use) => {
 457                    let tool_call = open_ai::ToolCall {
 458                        id: tool_use.id.to_string(),
 459                        content: open_ai::ToolCallContent::Function {
 460                            function: open_ai::FunctionContent {
 461                                name: tool_use.name.to_string(),
 462                                arguments: serde_json::to_string(&tool_use.input)
 463                                    .unwrap_or_default(),
 464                            },
 465                        },
 466                    };
 467
 468                    if let Some(open_ai::RequestMessage::Assistant { tool_calls, .. }) =
 469                        messages.last_mut()
 470                    {
 471                        tool_calls.push(tool_call);
 472                    } else {
 473                        messages.push(open_ai::RequestMessage::Assistant {
 474                            content: None,
 475                            tool_calls: vec![tool_call],
 476                        });
 477                    }
 478                }
 479                MessageContent::ToolResult(tool_result) => {
 480                    let content = match &tool_result.content {
 481                        LanguageModelToolResultContent::Text(text) => {
 482                            vec![open_ai::MessagePart::Text {
 483                                text: text.to_string(),
 484                            }]
 485                        }
 486                        LanguageModelToolResultContent::Image(image) => {
 487                            vec![open_ai::MessagePart::Image {
 488                                image_url: ImageUrl {
 489                                    url: image.to_base64_url(),
 490                                    detail: None,
 491                                },
 492                            }]
 493                        }
 494                    };
 495
 496                    messages.push(open_ai::RequestMessage::Tool {
 497                        content: content.into(),
 498                        tool_call_id: tool_result.tool_use_id.to_string(),
 499                    });
 500                }
 501            }
 502        }
 503    }
 504
 505    open_ai::Request {
 506        model: model_id.into(),
 507        messages,
 508        stream,
 509        stop: request.stop,
 510        temperature: request.temperature.or(Some(1.0)),
 511        max_completion_tokens: max_output_tokens,
 512        parallel_tool_calls: if supports_parallel_tool_calls && !request.tools.is_empty() {
 513            // Disable parallel tool calls, as the Agent currently expects a maximum of one per turn.
 514            Some(false)
 515        } else {
 516            None
 517        },
 518        prompt_cache_key: if supports_prompt_cache_key {
 519            request.thread_id
 520        } else {
 521            None
 522        },
 523        tools: request
 524            .tools
 525            .into_iter()
 526            .map(|tool| open_ai::ToolDefinition::Function {
 527                function: open_ai::FunctionDefinition {
 528                    name: tool.name,
 529                    description: Some(tool.description),
 530                    parameters: Some(tool.input_schema),
 531                },
 532            })
 533            .collect(),
 534        tool_choice: request.tool_choice.map(|choice| match choice {
 535            LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
 536            LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
 537            LanguageModelToolChoice::None => open_ai::ToolChoice::None,
 538        }),
 539        reasoning_effort,
 540    }
 541}
 542
 543pub fn into_open_ai_response(
 544    request: LanguageModelRequest,
 545    model_id: &str,
 546    supports_parallel_tool_calls: bool,
 547    supports_prompt_cache_key: bool,
 548    max_output_tokens: Option<u64>,
 549    reasoning_effort: Option<ReasoningEffort>,
 550) -> ResponseRequest {
 551    let stream = !model_id.starts_with("o1-");
 552
 553    let LanguageModelRequest {
 554        thread_id,
 555        prompt_id: _,
 556        intent: _,
 557        messages,
 558        tools,
 559        tool_choice,
 560        stop: _,
 561        temperature,
 562        thinking_allowed: _,
 563        thinking_effort: _,
 564        speed: _,
 565    } = request;
 566
 567    let mut input_items = Vec::new();
 568    for (index, message) in messages.into_iter().enumerate() {
 569        append_message_to_response_items(message, index, &mut input_items);
 570    }
 571
 572    let tools: Vec<_> = tools
 573        .into_iter()
 574        .map(|tool| open_ai::responses::ToolDefinition::Function {
 575            name: tool.name,
 576            description: Some(tool.description),
 577            parameters: Some(tool.input_schema),
 578            strict: None,
 579        })
 580        .collect();
 581
 582    ResponseRequest {
 583        model: model_id.into(),
 584        input: input_items,
 585        stream,
 586        temperature,
 587        top_p: None,
 588        max_output_tokens,
 589        parallel_tool_calls: if tools.is_empty() {
 590            None
 591        } else {
 592            Some(supports_parallel_tool_calls)
 593        },
 594        tool_choice: tool_choice.map(|choice| match choice {
 595            LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
 596            LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
 597            LanguageModelToolChoice::None => open_ai::ToolChoice::None,
 598        }),
 599        tools,
 600        prompt_cache_key: if supports_prompt_cache_key {
 601            thread_id
 602        } else {
 603            None
 604        },
 605        reasoning: reasoning_effort.map(|effort| open_ai::responses::ReasoningConfig { effort }),
 606    }
 607}
 608
 609fn append_message_to_response_items(
 610    message: LanguageModelRequestMessage,
 611    index: usize,
 612    input_items: &mut Vec<ResponseInputItem>,
 613) {
 614    let mut content_parts: Vec<ResponseInputContent> = Vec::new();
 615
 616    for content in message.content {
 617        match content {
 618            MessageContent::Text(text) => {
 619                push_response_text_part(&message.role, text, &mut content_parts);
 620            }
 621            MessageContent::Thinking { text, .. } => {
 622                push_response_text_part(&message.role, text, &mut content_parts);
 623            }
 624            MessageContent::RedactedThinking(_) => {}
 625            MessageContent::Image(image) => {
 626                push_response_image_part(&message.role, image, &mut content_parts);
 627            }
 628            MessageContent::ToolUse(tool_use) => {
 629                flush_response_parts(&message.role, index, &mut content_parts, input_items);
 630                let call_id = tool_use.id.to_string();
 631                input_items.push(ResponseInputItem::FunctionCall(ResponseFunctionCallItem {
 632                    call_id,
 633                    name: tool_use.name.to_string(),
 634                    arguments: tool_use.raw_input,
 635                }));
 636            }
 637            MessageContent::ToolResult(tool_result) => {
 638                flush_response_parts(&message.role, index, &mut content_parts, input_items);
 639                input_items.push(ResponseInputItem::FunctionCallOutput(
 640                    ResponseFunctionCallOutputItem {
 641                        call_id: tool_result.tool_use_id.to_string(),
 642                        output: tool_result_output(&tool_result),
 643                    },
 644                ));
 645            }
 646        }
 647    }
 648
 649    flush_response_parts(&message.role, index, &mut content_parts, input_items);
 650}
 651
 652fn push_response_text_part(
 653    role: &Role,
 654    text: impl Into<String>,
 655    parts: &mut Vec<ResponseInputContent>,
 656) {
 657    let text = text.into();
 658    if text.trim().is_empty() {
 659        return;
 660    }
 661
 662    match role {
 663        Role::Assistant => parts.push(ResponseInputContent::OutputText {
 664            text,
 665            annotations: Vec::new(),
 666        }),
 667        _ => parts.push(ResponseInputContent::Text { text }),
 668    }
 669}
 670
 671fn push_response_image_part(
 672    role: &Role,
 673    image: LanguageModelImage,
 674    parts: &mut Vec<ResponseInputContent>,
 675) {
 676    match role {
 677        Role::Assistant => parts.push(ResponseInputContent::OutputText {
 678            text: "[image omitted]".to_string(),
 679            annotations: Vec::new(),
 680        }),
 681        _ => parts.push(ResponseInputContent::Image {
 682            image_url: image.to_base64_url(),
 683        }),
 684    }
 685}
 686
 687fn flush_response_parts(
 688    role: &Role,
 689    _index: usize,
 690    parts: &mut Vec<ResponseInputContent>,
 691    input_items: &mut Vec<ResponseInputItem>,
 692) {
 693    if parts.is_empty() {
 694        return;
 695    }
 696
 697    let item = ResponseInputItem::Message(ResponseMessageItem {
 698        role: match role {
 699            Role::User => open_ai::Role::User,
 700            Role::Assistant => open_ai::Role::Assistant,
 701            Role::System => open_ai::Role::System,
 702        },
 703        content: parts.clone(),
 704    });
 705
 706    input_items.push(item);
 707    parts.clear();
 708}
 709
 710fn tool_result_output(result: &LanguageModelToolResult) -> String {
 711    if let Some(output) = &result.output {
 712        match output {
 713            serde_json::Value::String(text) => text.clone(),
 714            serde_json::Value::Null => String::new(),
 715            _ => output.to_string(),
 716        }
 717    } else {
 718        match &result.content {
 719            LanguageModelToolResultContent::Text(text) => text.to_string(),
 720            LanguageModelToolResultContent::Image(image) => image.to_base64_url(),
 721        }
 722    }
 723}
 724
 725fn add_message_content_part(
 726    new_part: open_ai::MessagePart,
 727    role: Role,
 728    messages: &mut Vec<open_ai::RequestMessage>,
 729) {
 730    match (role, messages.last_mut()) {
 731        (Role::User, Some(open_ai::RequestMessage::User { content }))
 732        | (
 733            Role::Assistant,
 734            Some(open_ai::RequestMessage::Assistant {
 735                content: Some(content),
 736                ..
 737            }),
 738        )
 739        | (Role::System, Some(open_ai::RequestMessage::System { content, .. })) => {
 740            content.push_part(new_part);
 741        }
 742        _ => {
 743            messages.push(match role {
 744                Role::User => open_ai::RequestMessage::User {
 745                    content: open_ai::MessageContent::from(vec![new_part]),
 746                },
 747                Role::Assistant => open_ai::RequestMessage::Assistant {
 748                    content: Some(open_ai::MessageContent::from(vec![new_part])),
 749                    tool_calls: Vec::new(),
 750                },
 751                Role::System => open_ai::RequestMessage::System {
 752                    content: open_ai::MessageContent::from(vec![new_part]),
 753                },
 754            });
 755        }
 756    }
 757}
 758
 759pub struct OpenAiEventMapper {
 760    tool_calls_by_index: HashMap<usize, RawToolCall>,
 761}
 762
 763impl OpenAiEventMapper {
 764    pub fn new() -> Self {
 765        Self {
 766            tool_calls_by_index: HashMap::default(),
 767        }
 768    }
 769
 770    pub fn map_stream(
 771        mut self,
 772        events: Pin<Box<dyn Send + Stream<Item = Result<ResponseStreamEvent>>>>,
 773    ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
 774    {
 775        events.flat_map(move |event| {
 776            futures::stream::iter(match event {
 777                Ok(event) => self.map_event(event),
 778                Err(error) => vec![Err(LanguageModelCompletionError::from(anyhow!(error)))],
 779            })
 780        })
 781    }
 782
 783    pub fn map_event(
 784        &mut self,
 785        event: ResponseStreamEvent,
 786    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
 787        let mut events = Vec::new();
 788        if let Some(usage) = event.usage {
 789            events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
 790                input_tokens: usage.prompt_tokens,
 791                output_tokens: usage.completion_tokens,
 792                cache_creation_input_tokens: 0,
 793                cache_read_input_tokens: 0,
 794            })));
 795        }
 796
 797        let Some(choice) = event.choices.first() else {
 798            return events;
 799        };
 800
 801        if let Some(delta) = choice.delta.as_ref() {
 802            if let Some(reasoning_content) = delta.reasoning_content.clone() {
 803                if !reasoning_content.is_empty() {
 804                    events.push(Ok(LanguageModelCompletionEvent::Thinking {
 805                        text: reasoning_content,
 806                        signature: None,
 807                    }));
 808                }
 809            }
 810            if let Some(content) = delta.content.clone() {
 811                if !content.is_empty() {
 812                    events.push(Ok(LanguageModelCompletionEvent::Text(content)));
 813                }
 814            }
 815
 816            if let Some(tool_calls) = delta.tool_calls.as_ref() {
 817                for tool_call in tool_calls {
 818                    let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();
 819
 820                    if let Some(tool_id) = tool_call.id.clone() {
 821                        entry.id = tool_id;
 822                    }
 823
 824                    if let Some(function) = tool_call.function.as_ref() {
 825                        if let Some(name) = function.name.clone() {
 826                            entry.name = name;
 827                        }
 828
 829                        if let Some(arguments) = function.arguments.clone() {
 830                            entry.arguments.push_str(&arguments);
 831                        }
 832                    }
 833
 834                    if !entry.id.is_empty() && !entry.name.is_empty() {
 835                        if let Ok(input) = serde_json::from_str::<serde_json::Value>(
 836                            &partial_json_fixer::fix_json(&entry.arguments),
 837                        ) {
 838                            events.push(Ok(LanguageModelCompletionEvent::ToolUse(
 839                                LanguageModelToolUse {
 840                                    id: entry.id.clone().into(),
 841                                    name: entry.name.as_str().into(),
 842                                    is_input_complete: false,
 843                                    input,
 844                                    raw_input: entry.arguments.clone(),
 845                                    thought_signature: None,
 846                                },
 847                            )));
 848                        }
 849                    }
 850                }
 851            }
 852        }
 853
 854        match choice.finish_reason.as_deref() {
 855            Some("stop") => {
 856                events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
 857            }
 858            Some("tool_calls") => {
 859                events.extend(self.tool_calls_by_index.drain().map(|(_, tool_call)| {
 860                    match parse_tool_arguments(&tool_call.arguments) {
 861                        Ok(input) => Ok(LanguageModelCompletionEvent::ToolUse(
 862                            LanguageModelToolUse {
 863                                id: tool_call.id.clone().into(),
 864                                name: tool_call.name.as_str().into(),
 865                                is_input_complete: true,
 866                                input,
 867                                raw_input: tool_call.arguments.clone(),
 868                                thought_signature: None,
 869                            },
 870                        )),
 871                        Err(error) => Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
 872                            id: tool_call.id.into(),
 873                            tool_name: tool_call.name.into(),
 874                            raw_input: tool_call.arguments.clone().into(),
 875                            json_parse_error: error.to_string(),
 876                        }),
 877                    }
 878                }));
 879
 880                events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));
 881            }
 882            Some(stop_reason) => {
 883                log::error!("Unexpected OpenAI stop_reason: {stop_reason:?}",);
 884                events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
 885            }
 886            None => {}
 887        }
 888
 889        events
 890    }
 891}
 892
 893#[derive(Default)]
 894struct RawToolCall {
 895    id: String,
 896    name: String,
 897    arguments: String,
 898}
 899
 900pub struct OpenAiResponseEventMapper {
 901    function_calls_by_item: HashMap<String, PendingResponseFunctionCall>,
 902    pending_stop_reason: Option<StopReason>,
 903}
 904
 905#[derive(Default)]
 906struct PendingResponseFunctionCall {
 907    call_id: String,
 908    name: Arc<str>,
 909    arguments: String,
 910}
 911
 912impl OpenAiResponseEventMapper {
 913    pub fn new() -> Self {
 914        Self {
 915            function_calls_by_item: HashMap::default(),
 916            pending_stop_reason: None,
 917        }
 918    }
 919
 920    pub fn map_stream(
 921        mut self,
 922        events: Pin<Box<dyn Send + Stream<Item = Result<ResponsesStreamEvent>>>>,
 923    ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
 924    {
 925        events.flat_map(move |event| {
 926            futures::stream::iter(match event {
 927                Ok(event) => self.map_event(event),
 928                Err(error) => vec![Err(LanguageModelCompletionError::from(anyhow!(error)))],
 929            })
 930        })
 931    }
 932
 933    pub fn map_event(
 934        &mut self,
 935        event: ResponsesStreamEvent,
 936    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
 937        match event {
 938            ResponsesStreamEvent::OutputItemAdded { item, .. } => {
 939                let mut events = Vec::new();
 940
 941                match &item {
 942                    ResponseOutputItem::Message(message) => {
 943                        if let Some(id) = &message.id {
 944                            events.push(Ok(LanguageModelCompletionEvent::StartMessage {
 945                                message_id: id.clone(),
 946                            }));
 947                        }
 948                    }
 949                    ResponseOutputItem::FunctionCall(function_call) => {
 950                        if let Some(item_id) = function_call.id.clone() {
 951                            let call_id = function_call
 952                                .call_id
 953                                .clone()
 954                                .or_else(|| function_call.id.clone())
 955                                .unwrap_or_else(|| item_id.clone());
 956                            let entry = PendingResponseFunctionCall {
 957                                call_id,
 958                                name: Arc::<str>::from(
 959                                    function_call.name.clone().unwrap_or_default(),
 960                                ),
 961                                arguments: function_call.arguments.clone(),
 962                            };
 963                            self.function_calls_by_item.insert(item_id, entry);
 964                        }
 965                    }
 966                    ResponseOutputItem::Unknown => {}
 967                }
 968                events
 969            }
 970            ResponsesStreamEvent::OutputTextDelta { delta, .. } => {
 971                if delta.is_empty() {
 972                    Vec::new()
 973                } else {
 974                    vec![Ok(LanguageModelCompletionEvent::Text(delta))]
 975                }
 976            }
 977            ResponsesStreamEvent::FunctionCallArgumentsDelta { item_id, delta, .. } => {
 978                if let Some(entry) = self.function_calls_by_item.get_mut(&item_id) {
 979                    entry.arguments.push_str(&delta);
 980                    if let Ok(input) = serde_json::from_str::<serde_json::Value>(
 981                        &partial_json_fixer::fix_json(&entry.arguments),
 982                    ) {
 983                        return vec![Ok(LanguageModelCompletionEvent::ToolUse(
 984                            LanguageModelToolUse {
 985                                id: LanguageModelToolUseId::from(entry.call_id.clone()),
 986                                name: entry.name.clone(),
 987                                is_input_complete: false,
 988                                input,
 989                                raw_input: entry.arguments.clone(),
 990                                thought_signature: None,
 991                            },
 992                        ))];
 993                    }
 994                }
 995                Vec::new()
 996            }
 997            ResponsesStreamEvent::FunctionCallArgumentsDone {
 998                item_id, arguments, ..
 999            } => {
1000                if let Some(mut entry) = self.function_calls_by_item.remove(&item_id) {
1001                    if !arguments.is_empty() {
1002                        entry.arguments = arguments;
1003                    }
1004                    let raw_input = entry.arguments.clone();
1005                    self.pending_stop_reason = Some(StopReason::ToolUse);
1006                    match parse_tool_arguments(&entry.arguments) {
1007                        Ok(input) => {
1008                            vec![Ok(LanguageModelCompletionEvent::ToolUse(
1009                                LanguageModelToolUse {
1010                                    id: LanguageModelToolUseId::from(entry.call_id.clone()),
1011                                    name: entry.name.clone(),
1012                                    is_input_complete: true,
1013                                    input,
1014                                    raw_input,
1015                                    thought_signature: None,
1016                                },
1017                            ))]
1018                        }
1019                        Err(error) => {
1020                            vec![Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
1021                                id: LanguageModelToolUseId::from(entry.call_id.clone()),
1022                                tool_name: entry.name.clone(),
1023                                raw_input: Arc::<str>::from(raw_input),
1024                                json_parse_error: error.to_string(),
1025                            })]
1026                        }
1027                    }
1028                } else {
1029                    Vec::new()
1030                }
1031            }
1032            ResponsesStreamEvent::Completed { response } => {
1033                self.handle_completion(response, StopReason::EndTurn)
1034            }
1035            ResponsesStreamEvent::Incomplete { response } => {
1036                let reason = response
1037                    .status_details
1038                    .as_ref()
1039                    .and_then(|details| details.reason.as_deref());
1040                let stop_reason = match reason {
1041                    Some("max_output_tokens") => StopReason::MaxTokens,
1042                    Some("content_filter") => {
1043                        self.pending_stop_reason = Some(StopReason::Refusal);
1044                        StopReason::Refusal
1045                    }
1046                    _ => self
1047                        .pending_stop_reason
1048                        .take()
1049                        .unwrap_or(StopReason::EndTurn),
1050                };
1051
1052                let mut events = Vec::new();
1053                if self.pending_stop_reason.is_none() {
1054                    events.extend(self.emit_tool_calls_from_output(&response.output));
1055                }
1056                if let Some(usage) = response.usage.as_ref() {
1057                    events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(
1058                        token_usage_from_response_usage(usage),
1059                    )));
1060                }
1061                events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));
1062                events
1063            }
1064            ResponsesStreamEvent::Failed { response } => {
1065                let message = response
1066                    .status_details
1067                    .and_then(|details| details.error)
1068                    .map(|error| error.to_string())
1069                    .unwrap_or_else(|| "response failed".to_string());
1070                vec![Err(LanguageModelCompletionError::Other(anyhow!(message)))]
1071            }
1072            ResponsesStreamEvent::Error { error }
1073            | ResponsesStreamEvent::GenericError { error } => {
1074                vec![Err(LanguageModelCompletionError::Other(anyhow!(
1075                    error.message
1076                )))]
1077            }
1078            ResponsesStreamEvent::OutputTextDone { .. } => Vec::new(),
1079            ResponsesStreamEvent::OutputItemDone { .. }
1080            | ResponsesStreamEvent::ContentPartAdded { .. }
1081            | ResponsesStreamEvent::ContentPartDone { .. }
1082            | ResponsesStreamEvent::Created { .. }
1083            | ResponsesStreamEvent::InProgress { .. }
1084            | ResponsesStreamEvent::Unknown => Vec::new(),
1085        }
1086    }
1087
1088    fn handle_completion(
1089        &mut self,
1090        response: ResponsesSummary,
1091        default_reason: StopReason,
1092    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
1093        let mut events = Vec::new();
1094
1095        if self.pending_stop_reason.is_none() {
1096            events.extend(self.emit_tool_calls_from_output(&response.output));
1097        }
1098
1099        if let Some(usage) = response.usage.as_ref() {
1100            events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(
1101                token_usage_from_response_usage(usage),
1102            )));
1103        }
1104
1105        let stop_reason = self.pending_stop_reason.take().unwrap_or(default_reason);
1106        events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));
1107        events
1108    }
1109
1110    fn emit_tool_calls_from_output(
1111        &mut self,
1112        output: &[ResponseOutputItem],
1113    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
1114        let mut events = Vec::new();
1115        for item in output {
1116            if let ResponseOutputItem::FunctionCall(function_call) = item {
1117                let Some(call_id) = function_call
1118                    .call_id
1119                    .clone()
1120                    .or_else(|| function_call.id.clone())
1121                else {
1122                    log::error!(
1123                        "Function call item missing both call_id and id: {:?}",
1124                        function_call
1125                    );
1126                    continue;
1127                };
1128                let name: Arc<str> = Arc::from(function_call.name.clone().unwrap_or_default());
1129                let arguments = &function_call.arguments;
1130                self.pending_stop_reason = Some(StopReason::ToolUse);
1131                match parse_tool_arguments(arguments) {
1132                    Ok(input) => {
1133                        events.push(Ok(LanguageModelCompletionEvent::ToolUse(
1134                            LanguageModelToolUse {
1135                                id: LanguageModelToolUseId::from(call_id.clone()),
1136                                name: name.clone(),
1137                                is_input_complete: true,
1138                                input,
1139                                raw_input: arguments.clone(),
1140                                thought_signature: None,
1141                            },
1142                        )));
1143                    }
1144                    Err(error) => {
1145                        events.push(Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
1146                            id: LanguageModelToolUseId::from(call_id.clone()),
1147                            tool_name: name.clone(),
1148                            raw_input: Arc::<str>::from(arguments.clone()),
1149                            json_parse_error: error.to_string(),
1150                        }));
1151                    }
1152                }
1153            }
1154        }
1155        events
1156    }
1157}
1158
1159fn token_usage_from_response_usage(usage: &ResponsesUsage) -> TokenUsage {
1160    TokenUsage {
1161        input_tokens: usage.input_tokens.unwrap_or_default(),
1162        output_tokens: usage.output_tokens.unwrap_or_default(),
1163        cache_creation_input_tokens: 0,
1164        cache_read_input_tokens: 0,
1165    }
1166}
1167
1168pub(crate) fn collect_tiktoken_messages(
1169    request: LanguageModelRequest,
1170) -> Vec<tiktoken_rs::ChatCompletionRequestMessage> {
1171    request
1172        .messages
1173        .into_iter()
1174        .map(|message| tiktoken_rs::ChatCompletionRequestMessage {
1175            role: match message.role {
1176                Role::User => "user".into(),
1177                Role::Assistant => "assistant".into(),
1178                Role::System => "system".into(),
1179            },
1180            content: Some(message.string_contents()),
1181            name: None,
1182            function_call: None,
1183        })
1184        .collect::<Vec<_>>()
1185}
1186
1187pub fn count_open_ai_tokens(
1188    request: LanguageModelRequest,
1189    model: Model,
1190    cx: &App,
1191) -> BoxFuture<'static, Result<u64>> {
1192    cx.background_spawn(async move {
1193        let messages = collect_tiktoken_messages(request);
1194        match model {
1195            Model::Custom { max_tokens, .. } => {
1196                let model = if max_tokens >= 100_000 {
1197                    // If the max tokens is 100k or more, it likely uses the o200k_base tokenizer
1198                    "gpt-4o"
1199                } else {
1200                    // Otherwise fallback to gpt-4, since only cl100k_base and o200k_base are
1201                    // supported with this tiktoken method
1202                    "gpt-4"
1203                };
1204                tiktoken_rs::num_tokens_from_messages(model, &messages)
1205            }
1206            // Currently supported by tiktoken_rs
1207            // Sometimes tiktoken-rs is behind on model support. If that is the case, make a new branch
1208            // arm with an override. We enumerate all supported models here so that we can check if new
1209            // models are supported yet or not.
1210            Model::ThreePointFiveTurbo
1211            | Model::Four
1212            | Model::FourTurbo
1213            | Model::FourOmniMini
1214            | Model::FourPointOneNano
1215            | Model::O1
1216            | Model::O3
1217            | Model::O3Mini
1218            | Model::Five
1219            | Model::FiveCodex
1220            | Model::FiveMini
1221            | Model::FiveNano => tiktoken_rs::num_tokens_from_messages(model.id(), &messages),
1222            // GPT-5.1, 5.2, 5.2-codex, 5.3-codex, 5.4, and 5.4-pro don't have dedicated tiktoken support; use gpt-5 tokenizer
1223            Model::FivePointOne
1224            | Model::FivePointTwo
1225            | Model::FivePointTwoCodex
1226            | Model::FivePointThreeCodex
1227            | Model::FivePointFour
1228            | Model::FivePointFourPro => tiktoken_rs::num_tokens_from_messages("gpt-5", &messages),
1229        }
1230        .map(|tokens| tokens as u64)
1231    })
1232    .boxed()
1233}
1234
1235struct ConfigurationView {
1236    api_key_editor: Entity<InputField>,
1237    state: Entity<State>,
1238    load_credentials_task: Option<Task<()>>,
1239}
1240
1241impl ConfigurationView {
1242    fn new(state: Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
1243        let api_key_editor = cx.new(|cx| {
1244            InputField::new(
1245                window,
1246                cx,
1247                "sk-000000000000000000000000000000000000000000000000",
1248            )
1249        });
1250
1251        cx.observe(&state, |_, _, cx| {
1252            cx.notify();
1253        })
1254        .detach();
1255
1256        let load_credentials_task = Some(cx.spawn_in(window, {
1257            let state = state.clone();
1258            async move |this, cx| {
1259                if let Some(task) = Some(state.update(cx, |state, cx| state.authenticate(cx))) {
1260                    // We don't log an error, because "not signed in" is also an error.
1261                    let _ = task.await;
1262                }
1263                this.update(cx, |this, cx| {
1264                    this.load_credentials_task = None;
1265                    cx.notify();
1266                })
1267                .log_err();
1268            }
1269        }));
1270
1271        Self {
1272            api_key_editor,
1273            state,
1274            load_credentials_task,
1275        }
1276    }
1277
1278    fn save_api_key(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
1279        let api_key = self.api_key_editor.read(cx).text(cx).trim().to_string();
1280        if api_key.is_empty() {
1281            return;
1282        }
1283
1284        // url changes can cause the editor to be displayed again
1285        self.api_key_editor
1286            .update(cx, |editor, cx| editor.set_text("", window, cx));
1287
1288        let state = self.state.clone();
1289        cx.spawn_in(window, async move |_, cx| {
1290            state
1291                .update(cx, |state, cx| state.set_api_key(Some(api_key), cx))
1292                .await
1293        })
1294        .detach_and_log_err(cx);
1295    }
1296
1297    fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1298        self.api_key_editor
1299            .update(cx, |input, cx| input.set_text("", window, cx));
1300
1301        let state = self.state.clone();
1302        cx.spawn_in(window, async move |_, cx| {
1303            state
1304                .update(cx, |state, cx| state.set_api_key(None, cx))
1305                .await
1306        })
1307        .detach_and_log_err(cx);
1308    }
1309
1310    fn should_render_editor(&self, cx: &mut Context<Self>) -> bool {
1311        !self.state.read(cx).is_authenticated()
1312    }
1313}
1314
1315impl Render for ConfigurationView {
1316    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1317        let env_var_set = self.state.read(cx).api_key_state.is_from_env_var();
1318        let configured_card_label = if env_var_set {
1319            format!("API key set in {API_KEY_ENV_VAR_NAME} environment variable")
1320        } else {
1321            let api_url = OpenAiLanguageModelProvider::api_url(cx);
1322            if api_url == OPEN_AI_API_URL {
1323                "API key configured".to_string()
1324            } else {
1325                format!("API key configured for {}", api_url)
1326            }
1327        };
1328
1329        let api_key_section = if self.should_render_editor(cx) {
1330            v_flex()
1331                .on_action(cx.listener(Self::save_api_key))
1332                .child(Label::new("To use Zed's agent with OpenAI, you need to add an API key. Follow these steps:"))
1333                .child(
1334                    List::new()
1335                        .child(
1336                            ListBulletItem::new("")
1337                                .child(Label::new("Create one by visiting"))
1338                                .child(ButtonLink::new("OpenAI's console", "https://platform.openai.com/api-keys"))
1339                        )
1340                        .child(
1341                            ListBulletItem::new("Ensure your OpenAI account has credits")
1342                        )
1343                        .child(
1344                            ListBulletItem::new("Paste your API key below and hit enter to start using the agent")
1345                        ),
1346                )
1347                .child(self.api_key_editor.clone())
1348                .child(
1349                    Label::new(format!(
1350                        "You can also set the {API_KEY_ENV_VAR_NAME} environment variable and restart Zed."
1351                    ))
1352                    .size(LabelSize::Small)
1353                    .color(Color::Muted),
1354                )
1355                .child(
1356                    Label::new(
1357                        "Note that having a subscription for another service like GitHub Copilot won't work.",
1358                    )
1359                    .size(LabelSize::Small).color(Color::Muted),
1360                )
1361                .into_any_element()
1362        } else {
1363            ConfiguredApiCard::new(configured_card_label)
1364                .disabled(env_var_set)
1365                .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx)))
1366                .when(env_var_set, |this| {
1367                    this.tooltip_label(format!("To reset your API key, unset the {API_KEY_ENV_VAR_NAME} environment variable."))
1368                })
1369                .into_any_element()
1370        };
1371
1372        let compatible_api_section = h_flex()
1373            .mt_1p5()
1374            .gap_0p5()
1375            .flex_wrap()
1376            .when(self.should_render_editor(cx), |this| {
1377                this.pt_1p5()
1378                    .border_t_1()
1379                    .border_color(cx.theme().colors().border_variant)
1380            })
1381            .child(
1382                h_flex()
1383                    .gap_2()
1384                    .child(
1385                        Icon::new(IconName::Info)
1386                            .size(IconSize::XSmall)
1387                            .color(Color::Muted),
1388                    )
1389                    .child(Label::new("Zed also supports OpenAI-compatible models.")),
1390            )
1391            .child(
1392                Button::new("docs", "Learn More")
1393                    .icon(IconName::ArrowUpRight)
1394                    .icon_size(IconSize::Small)
1395                    .icon_color(Color::Muted)
1396                    .on_click(move |_, _window, cx| {
1397                        cx.open_url("https://zed.dev/docs/ai/llm-providers#openai-api-compatible")
1398                    }),
1399            );
1400
1401        if self.load_credentials_task.is_some() {
1402            div().child(Label::new("Loading credentials…")).into_any()
1403        } else {
1404            v_flex()
1405                .size_full()
1406                .child(api_key_section)
1407                .child(compatible_api_section)
1408                .into_any()
1409        }
1410    }
1411}
1412
1413#[cfg(test)]
1414mod tests {
1415    use futures::{StreamExt, executor::block_on};
1416    use gpui::TestAppContext;
1417    use language_model::{LanguageModelRequestMessage, LanguageModelRequestTool};
1418    use open_ai::responses::{
1419        ResponseFunctionToolCall, ResponseOutputItem, ResponseOutputMessage, ResponseStatusDetails,
1420        ResponseSummary, ResponseUsage, StreamEvent as ResponsesStreamEvent,
1421    };
1422    use pretty_assertions::assert_eq;
1423    use serde_json::json;
1424
1425    use super::*;
1426
1427    fn map_response_events(events: Vec<ResponsesStreamEvent>) -> Vec<LanguageModelCompletionEvent> {
1428        block_on(async {
1429            OpenAiResponseEventMapper::new()
1430                .map_stream(Box::pin(futures::stream::iter(events.into_iter().map(Ok))))
1431                .collect::<Vec<_>>()
1432                .await
1433                .into_iter()
1434                .map(Result::unwrap)
1435                .collect()
1436        })
1437    }
1438
1439    fn response_item_message(id: &str) -> ResponseOutputItem {
1440        ResponseOutputItem::Message(ResponseOutputMessage {
1441            id: Some(id.to_string()),
1442            role: Some("assistant".to_string()),
1443            status: Some("in_progress".to_string()),
1444            content: vec![],
1445        })
1446    }
1447
1448    fn response_item_function_call(id: &str, args: Option<&str>) -> ResponseOutputItem {
1449        ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
1450            id: Some(id.to_string()),
1451            status: Some("in_progress".to_string()),
1452            name: Some("get_weather".to_string()),
1453            call_id: Some("call_123".to_string()),
1454            arguments: args.map(|s| s.to_string()).unwrap_or_default(),
1455        })
1456    }
1457
1458    #[gpui::test]
1459    fn tiktoken_rs_support(cx: &TestAppContext) {
1460        let request = LanguageModelRequest {
1461            thread_id: None,
1462            prompt_id: None,
1463            intent: None,
1464            messages: vec![LanguageModelRequestMessage {
1465                role: Role::User,
1466                content: vec![MessageContent::Text("message".into())],
1467                cache: false,
1468                reasoning_details: None,
1469            }],
1470            tools: vec![],
1471            tool_choice: None,
1472            stop: vec![],
1473            temperature: None,
1474            thinking_allowed: true,
1475            thinking_effort: None,
1476            speed: None,
1477        };
1478
1479        // Validate that all models are supported by tiktoken-rs
1480        for model in Model::iter() {
1481            let count = cx
1482                .foreground_executor()
1483                .block_on(count_open_ai_tokens(
1484                    request.clone(),
1485                    model,
1486                    &cx.app.borrow(),
1487                ))
1488                .unwrap();
1489            assert!(count > 0);
1490        }
1491    }
1492
1493    #[test]
1494    fn responses_stream_maps_text_and_usage() {
1495        let events = vec![
1496            ResponsesStreamEvent::OutputItemAdded {
1497                output_index: 0,
1498                sequence_number: None,
1499                item: response_item_message("msg_123"),
1500            },
1501            ResponsesStreamEvent::OutputTextDelta {
1502                item_id: "msg_123".into(),
1503                output_index: 0,
1504                content_index: Some(0),
1505                delta: "Hello".into(),
1506            },
1507            ResponsesStreamEvent::Completed {
1508                response: ResponseSummary {
1509                    usage: Some(ResponseUsage {
1510                        input_tokens: Some(5),
1511                        output_tokens: Some(3),
1512                        total_tokens: Some(8),
1513                    }),
1514                    ..Default::default()
1515                },
1516            },
1517        ];
1518
1519        let mapped = map_response_events(events);
1520        assert!(matches!(
1521            mapped[0],
1522            LanguageModelCompletionEvent::StartMessage { ref message_id } if message_id == "msg_123"
1523        ));
1524        assert!(matches!(
1525            mapped[1],
1526            LanguageModelCompletionEvent::Text(ref text) if text == "Hello"
1527        ));
1528        assert!(matches!(
1529            mapped[2],
1530            LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1531                input_tokens: 5,
1532                output_tokens: 3,
1533                ..
1534            })
1535        ));
1536        assert!(matches!(
1537            mapped[3],
1538            LanguageModelCompletionEvent::Stop(StopReason::EndTurn)
1539        ));
1540    }
1541
1542    #[test]
1543    fn into_open_ai_response_builds_complete_payload() {
1544        let tool_call_id = LanguageModelToolUseId::from("call-42");
1545        let tool_input = json!({ "city": "Boston" });
1546        let tool_arguments = serde_json::to_string(&tool_input).unwrap();
1547        let tool_use = LanguageModelToolUse {
1548            id: tool_call_id.clone(),
1549            name: Arc::from("get_weather"),
1550            raw_input: tool_arguments.clone(),
1551            input: tool_input,
1552            is_input_complete: true,
1553            thought_signature: None,
1554        };
1555        let tool_result = LanguageModelToolResult {
1556            tool_use_id: tool_call_id,
1557            tool_name: Arc::from("get_weather"),
1558            is_error: false,
1559            content: LanguageModelToolResultContent::Text(Arc::from("Sunny")),
1560            output: Some(json!({ "forecast": "Sunny" })),
1561        };
1562        let user_image = LanguageModelImage {
1563            source: SharedString::from("aGVsbG8="),
1564            size: None,
1565        };
1566        let expected_image_url = user_image.to_base64_url();
1567
1568        let request = LanguageModelRequest {
1569            thread_id: Some("thread-123".into()),
1570            prompt_id: None,
1571            intent: None,
1572            messages: vec![
1573                LanguageModelRequestMessage {
1574                    role: Role::System,
1575                    content: vec![MessageContent::Text("System context".into())],
1576                    cache: false,
1577                    reasoning_details: None,
1578                },
1579                LanguageModelRequestMessage {
1580                    role: Role::User,
1581                    content: vec![
1582                        MessageContent::Text("Please check the weather.".into()),
1583                        MessageContent::Image(user_image),
1584                    ],
1585                    cache: false,
1586                    reasoning_details: None,
1587                },
1588                LanguageModelRequestMessage {
1589                    role: Role::Assistant,
1590                    content: vec![
1591                        MessageContent::Text("Looking that up.".into()),
1592                        MessageContent::ToolUse(tool_use),
1593                    ],
1594                    cache: false,
1595                    reasoning_details: None,
1596                },
1597                LanguageModelRequestMessage {
1598                    role: Role::Assistant,
1599                    content: vec![MessageContent::ToolResult(tool_result)],
1600                    cache: false,
1601                    reasoning_details: None,
1602                },
1603            ],
1604            tools: vec![LanguageModelRequestTool {
1605                name: "get_weather".into(),
1606                description: "Fetches the weather".into(),
1607                input_schema: json!({ "type": "object" }),
1608                use_input_streaming: false,
1609            }],
1610            tool_choice: Some(LanguageModelToolChoice::Any),
1611            stop: vec!["<STOP>".into()],
1612            temperature: None,
1613            thinking_allowed: false,
1614            thinking_effort: None,
1615            speed: None,
1616        };
1617
1618        let response = into_open_ai_response(
1619            request,
1620            "custom-model",
1621            true,
1622            true,
1623            Some(2048),
1624            Some(ReasoningEffort::Low),
1625        );
1626
1627        let serialized = serde_json::to_value(&response).unwrap();
1628        let expected = json!({
1629            "model": "custom-model",
1630            "input": [
1631                {
1632                    "type": "message",
1633                    "role": "system",
1634                    "content": [
1635                        { "type": "input_text", "text": "System context" }
1636                    ]
1637                },
1638                {
1639                    "type": "message",
1640                    "role": "user",
1641                    "content": [
1642                        { "type": "input_text", "text": "Please check the weather." },
1643                        { "type": "input_image", "image_url": expected_image_url }
1644                    ]
1645                },
1646                {
1647                    "type": "message",
1648                    "role": "assistant",
1649                    "content": [
1650                        { "type": "output_text", "text": "Looking that up.", "annotations": [] }
1651                    ]
1652                },
1653                {
1654                    "type": "function_call",
1655                    "call_id": "call-42",
1656                    "name": "get_weather",
1657                    "arguments": tool_arguments
1658                },
1659                {
1660                    "type": "function_call_output",
1661                    "call_id": "call-42",
1662                    "output": "{\"forecast\":\"Sunny\"}"
1663                }
1664            ],
1665            "stream": true,
1666            "max_output_tokens": 2048,
1667            "parallel_tool_calls": true,
1668            "tool_choice": "required",
1669            "tools": [
1670                {
1671                    "type": "function",
1672                    "name": "get_weather",
1673                    "description": "Fetches the weather",
1674                    "parameters": { "type": "object" }
1675                }
1676            ],
1677            "prompt_cache_key": "thread-123",
1678            "reasoning": { "effort": "low" }
1679        });
1680
1681        assert_eq!(serialized, expected);
1682    }
1683
1684    #[test]
1685    fn responses_stream_maps_tool_calls() {
1686        let events = vec![
1687            ResponsesStreamEvent::OutputItemAdded {
1688                output_index: 0,
1689                sequence_number: None,
1690                item: response_item_function_call("item_fn", Some("{\"city\":\"Bos")),
1691            },
1692            ResponsesStreamEvent::FunctionCallArgumentsDelta {
1693                item_id: "item_fn".into(),
1694                output_index: 0,
1695                delta: "ton\"}".into(),
1696                sequence_number: None,
1697            },
1698            ResponsesStreamEvent::FunctionCallArgumentsDone {
1699                item_id: "item_fn".into(),
1700                output_index: 0,
1701                arguments: "{\"city\":\"Boston\"}".into(),
1702                sequence_number: None,
1703            },
1704            ResponsesStreamEvent::Completed {
1705                response: ResponseSummary::default(),
1706            },
1707        ];
1708
1709        let mapped = map_response_events(events);
1710        assert_eq!(mapped.len(), 3);
1711        // First event is the partial tool use (from FunctionCallArgumentsDelta)
1712        assert!(matches!(
1713            mapped[0],
1714            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1715                is_input_complete: false,
1716                ..
1717            })
1718        ));
1719        // Second event is the complete tool use (from FunctionCallArgumentsDone)
1720        assert!(matches!(
1721            mapped[1],
1722            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1723                ref id,
1724                ref name,
1725                ref raw_input,
1726                is_input_complete: true,
1727                ..
1728            }) if id.to_string() == "call_123"
1729                && name.as_ref() == "get_weather"
1730                && raw_input == "{\"city\":\"Boston\"}"
1731        ));
1732        assert!(matches!(
1733            mapped[2],
1734            LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1735        ));
1736    }
1737
1738    #[test]
1739    fn responses_stream_uses_max_tokens_stop_reason() {
1740        let events = vec![ResponsesStreamEvent::Incomplete {
1741            response: ResponseSummary {
1742                status_details: Some(ResponseStatusDetails {
1743                    reason: Some("max_output_tokens".into()),
1744                    r#type: Some("incomplete".into()),
1745                    error: None,
1746                }),
1747                usage: Some(ResponseUsage {
1748                    input_tokens: Some(10),
1749                    output_tokens: Some(20),
1750                    total_tokens: Some(30),
1751                }),
1752                ..Default::default()
1753            },
1754        }];
1755
1756        let mapped = map_response_events(events);
1757        assert!(matches!(
1758            mapped[0],
1759            LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1760                input_tokens: 10,
1761                output_tokens: 20,
1762                ..
1763            })
1764        ));
1765        assert!(matches!(
1766            mapped[1],
1767            LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1768        ));
1769    }
1770
1771    #[test]
1772    fn responses_stream_handles_multiple_tool_calls() {
1773        let events = vec![
1774            ResponsesStreamEvent::OutputItemAdded {
1775                output_index: 0,
1776                sequence_number: None,
1777                item: response_item_function_call("item_fn1", Some("{\"city\":\"NYC\"}")),
1778            },
1779            ResponsesStreamEvent::FunctionCallArgumentsDone {
1780                item_id: "item_fn1".into(),
1781                output_index: 0,
1782                arguments: "{\"city\":\"NYC\"}".into(),
1783                sequence_number: None,
1784            },
1785            ResponsesStreamEvent::OutputItemAdded {
1786                output_index: 1,
1787                sequence_number: None,
1788                item: response_item_function_call("item_fn2", Some("{\"city\":\"LA\"}")),
1789            },
1790            ResponsesStreamEvent::FunctionCallArgumentsDone {
1791                item_id: "item_fn2".into(),
1792                output_index: 1,
1793                arguments: "{\"city\":\"LA\"}".into(),
1794                sequence_number: None,
1795            },
1796            ResponsesStreamEvent::Completed {
1797                response: ResponseSummary::default(),
1798            },
1799        ];
1800
1801        let mapped = map_response_events(events);
1802        assert_eq!(mapped.len(), 3);
1803        assert!(matches!(
1804            mapped[0],
1805            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1806            if raw_input == "{\"city\":\"NYC\"}"
1807        ));
1808        assert!(matches!(
1809            mapped[1],
1810            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1811            if raw_input == "{\"city\":\"LA\"}"
1812        ));
1813        assert!(matches!(
1814            mapped[2],
1815            LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1816        ));
1817    }
1818
1819    #[test]
1820    fn responses_stream_handles_mixed_text_and_tool_calls() {
1821        let events = vec![
1822            ResponsesStreamEvent::OutputItemAdded {
1823                output_index: 0,
1824                sequence_number: None,
1825                item: response_item_message("msg_123"),
1826            },
1827            ResponsesStreamEvent::OutputTextDelta {
1828                item_id: "msg_123".into(),
1829                output_index: 0,
1830                content_index: Some(0),
1831                delta: "Let me check that".into(),
1832            },
1833            ResponsesStreamEvent::OutputItemAdded {
1834                output_index: 1,
1835                sequence_number: None,
1836                item: response_item_function_call("item_fn", Some("{\"query\":\"test\"}")),
1837            },
1838            ResponsesStreamEvent::FunctionCallArgumentsDone {
1839                item_id: "item_fn".into(),
1840                output_index: 1,
1841                arguments: "{\"query\":\"test\"}".into(),
1842                sequence_number: None,
1843            },
1844            ResponsesStreamEvent::Completed {
1845                response: ResponseSummary::default(),
1846            },
1847        ];
1848
1849        let mapped = map_response_events(events);
1850        assert!(matches!(
1851            mapped[0],
1852            LanguageModelCompletionEvent::StartMessage { .. }
1853        ));
1854        assert!(matches!(
1855            mapped[1],
1856            LanguageModelCompletionEvent::Text(ref text) if text == "Let me check that"
1857        ));
1858        assert!(matches!(
1859            mapped[2],
1860            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1861            if raw_input == "{\"query\":\"test\"}"
1862        ));
1863        assert!(matches!(
1864            mapped[3],
1865            LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1866        ));
1867    }
1868
1869    #[test]
1870    fn responses_stream_handles_json_parse_error() {
1871        let events = vec![
1872            ResponsesStreamEvent::OutputItemAdded {
1873                output_index: 0,
1874                sequence_number: None,
1875                item: response_item_function_call("item_fn", Some("{invalid json")),
1876            },
1877            ResponsesStreamEvent::FunctionCallArgumentsDone {
1878                item_id: "item_fn".into(),
1879                output_index: 0,
1880                arguments: "{invalid json".into(),
1881                sequence_number: None,
1882            },
1883            ResponsesStreamEvent::Completed {
1884                response: ResponseSummary::default(),
1885            },
1886        ];
1887
1888        let mapped = map_response_events(events);
1889        assert!(matches!(
1890            mapped[0],
1891            LanguageModelCompletionEvent::ToolUseJsonParseError {
1892                ref raw_input,
1893                ..
1894            } if raw_input.as_ref() == "{invalid json"
1895        ));
1896    }
1897
1898    #[test]
1899    fn responses_stream_handles_incomplete_function_call() {
1900        let events = vec![
1901            ResponsesStreamEvent::OutputItemAdded {
1902                output_index: 0,
1903                sequence_number: None,
1904                item: response_item_function_call("item_fn", Some("{\"city\":")),
1905            },
1906            ResponsesStreamEvent::FunctionCallArgumentsDelta {
1907                item_id: "item_fn".into(),
1908                output_index: 0,
1909                delta: "\"Boston\"".into(),
1910                sequence_number: None,
1911            },
1912            ResponsesStreamEvent::Incomplete {
1913                response: ResponseSummary {
1914                    status_details: Some(ResponseStatusDetails {
1915                        reason: Some("max_output_tokens".into()),
1916                        r#type: Some("incomplete".into()),
1917                        error: None,
1918                    }),
1919                    output: vec![response_item_function_call(
1920                        "item_fn",
1921                        Some("{\"city\":\"Boston\"}"),
1922                    )],
1923                    ..Default::default()
1924                },
1925            },
1926        ];
1927
1928        let mapped = map_response_events(events);
1929        assert_eq!(mapped.len(), 3);
1930        // First event is the partial tool use (from FunctionCallArgumentsDelta)
1931        assert!(matches!(
1932            mapped[0],
1933            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1934                is_input_complete: false,
1935                ..
1936            })
1937        ));
1938        // Second event is the complete tool use (from the Incomplete response output)
1939        assert!(matches!(
1940            mapped[1],
1941            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1942                ref raw_input,
1943                is_input_complete: true,
1944                ..
1945            })
1946            if raw_input == "{\"city\":\"Boston\"}"
1947        ));
1948        assert!(matches!(
1949            mapped[2],
1950            LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1951        ));
1952    }
1953
1954    #[test]
1955    fn responses_stream_incomplete_does_not_duplicate_tool_calls() {
1956        let events = vec![
1957            ResponsesStreamEvent::OutputItemAdded {
1958                output_index: 0,
1959                sequence_number: None,
1960                item: response_item_function_call("item_fn", Some("{\"city\":\"Boston\"}")),
1961            },
1962            ResponsesStreamEvent::FunctionCallArgumentsDone {
1963                item_id: "item_fn".into(),
1964                output_index: 0,
1965                arguments: "{\"city\":\"Boston\"}".into(),
1966                sequence_number: None,
1967            },
1968            ResponsesStreamEvent::Incomplete {
1969                response: ResponseSummary {
1970                    status_details: Some(ResponseStatusDetails {
1971                        reason: Some("max_output_tokens".into()),
1972                        r#type: Some("incomplete".into()),
1973                        error: None,
1974                    }),
1975                    output: vec![response_item_function_call(
1976                        "item_fn",
1977                        Some("{\"city\":\"Boston\"}"),
1978                    )],
1979                    ..Default::default()
1980                },
1981            },
1982        ];
1983
1984        let mapped = map_response_events(events);
1985        assert_eq!(mapped.len(), 2);
1986        assert!(matches!(
1987            mapped[0],
1988            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1989            if raw_input == "{\"city\":\"Boston\"}"
1990        ));
1991        assert!(matches!(
1992            mapped[1],
1993            LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1994        ));
1995    }
1996
1997    #[test]
1998    fn responses_stream_handles_empty_tool_arguments() {
1999        // Test that tools with no arguments (empty string) are handled correctly
2000        let events = vec![
2001            ResponsesStreamEvent::OutputItemAdded {
2002                output_index: 0,
2003                sequence_number: None,
2004                item: response_item_function_call("item_fn", Some("")),
2005            },
2006            ResponsesStreamEvent::FunctionCallArgumentsDone {
2007                item_id: "item_fn".into(),
2008                output_index: 0,
2009                arguments: "".into(),
2010                sequence_number: None,
2011            },
2012            ResponsesStreamEvent::Completed {
2013                response: ResponseSummary::default(),
2014            },
2015        ];
2016
2017        let mapped = map_response_events(events);
2018        assert_eq!(mapped.len(), 2);
2019
2020        // Should produce a ToolUse event with an empty object
2021        assert!(matches!(
2022            &mapped[0],
2023            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2024                id,
2025                name,
2026                raw_input,
2027                input,
2028                ..
2029            }) if id.to_string() == "call_123"
2030                && name.as_ref() == "get_weather"
2031                && raw_input == ""
2032                && input.is_object()
2033                && input.as_object().unwrap().is_empty()
2034        ));
2035
2036        assert!(matches!(
2037            mapped[1],
2038            LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
2039        ));
2040    }
2041
2042    #[test]
2043    fn responses_stream_emits_partial_tool_use_events() {
2044        let events = vec![
2045            ResponsesStreamEvent::OutputItemAdded {
2046                output_index: 0,
2047                sequence_number: None,
2048                item: ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
2049                    id: Some("item_fn".to_string()),
2050                    status: Some("in_progress".to_string()),
2051                    name: Some("get_weather".to_string()),
2052                    call_id: Some("call_abc".to_string()),
2053                    arguments: String::new(),
2054                }),
2055            },
2056            ResponsesStreamEvent::FunctionCallArgumentsDelta {
2057                item_id: "item_fn".into(),
2058                output_index: 0,
2059                delta: "{\"city\":\"Bos".into(),
2060                sequence_number: None,
2061            },
2062            ResponsesStreamEvent::FunctionCallArgumentsDelta {
2063                item_id: "item_fn".into(),
2064                output_index: 0,
2065                delta: "ton\"}".into(),
2066                sequence_number: None,
2067            },
2068            ResponsesStreamEvent::FunctionCallArgumentsDone {
2069                item_id: "item_fn".into(),
2070                output_index: 0,
2071                arguments: "{\"city\":\"Boston\"}".into(),
2072                sequence_number: None,
2073            },
2074            ResponsesStreamEvent::Completed {
2075                response: ResponseSummary::default(),
2076            },
2077        ];
2078
2079        let mapped = map_response_events(events);
2080        // Two partial events + one complete event + Stop
2081        assert!(mapped.len() >= 3);
2082
2083        // The last complete ToolUse event should have is_input_complete: true
2084        let complete_tool_use = mapped.iter().find(|e| {
2085            matches!(
2086                e,
2087                LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2088                    is_input_complete: true,
2089                    ..
2090                })
2091            )
2092        });
2093        assert!(
2094            complete_tool_use.is_some(),
2095            "should have a complete tool use event"
2096        );
2097
2098        // All ToolUse events before the final one should have is_input_complete: false
2099        let tool_uses: Vec<_> = mapped
2100            .iter()
2101            .filter(|e| matches!(e, LanguageModelCompletionEvent::ToolUse(_)))
2102            .collect();
2103        assert!(
2104            tool_uses.len() >= 2,
2105            "should have at least one partial and one complete event"
2106        );
2107
2108        let last = tool_uses.last().unwrap();
2109        assert!(matches!(
2110            last,
2111            LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2112                is_input_complete: true,
2113                ..
2114            })
2115        ));
2116    }
2117}