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