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