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