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