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