1use anyhow::{Result, anyhow};
2use collections::{BTreeMap, HashMap};
3use futures::Stream;
4use futures::{FutureExt, StreamExt, future::BoxFuture};
5use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window};
6use http_client::HttpClient;
7use language_model::{
8 ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError,
9 LanguageModelCompletionEvent, LanguageModelId, LanguageModelImage, LanguageModelName,
10 LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,
11 LanguageModelProviderState, LanguageModelRequest, LanguageModelRequestMessage,
12 LanguageModelToolChoice, LanguageModelToolResult, LanguageModelToolResultContent,
13 LanguageModelToolUse, LanguageModelToolUseId, MessageContent, RateLimiter, Role, StopReason,
14 TokenUsage, env_var,
15};
16use menu;
17use open_ai::responses::{
18 ResponseFunctionCallItem, ResponseFunctionCallOutputItem, ResponseInputContent,
19 ResponseInputItem, ResponseMessageItem,
20};
21use open_ai::{
22 ImageUrl, Model, OPEN_AI_API_URL, ReasoningEffort, ResponseStreamEvent,
23 responses::{
24 Request as ResponseRequest, ResponseOutputItem, ResponseSummary as ResponsesSummary,
25 ResponseUsage as ResponsesUsage, StreamEvent as ResponsesStreamEvent, stream_response,
26 },
27 stream_completion,
28};
29use settings::{OpenAiAvailableModel as AvailableModel, Settings, SettingsStore};
30use std::pin::Pin;
31use std::sync::{Arc, LazyLock};
32use strum::IntoEnumIterator;
33use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*};
34use ui_input::InputField;
35use util::ResultExt;
36
37use crate::provider::util::parse_tool_arguments;
38
39const PROVIDER_ID: LanguageModelProviderId = language_model::OPEN_AI_PROVIDER_ID;
40const PROVIDER_NAME: LanguageModelProviderName = language_model::OPEN_AI_PROVIDER_NAME;
41
42const API_KEY_ENV_VAR_NAME: &str = "OPENAI_API_KEY";
43static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
44
45#[derive(Default, Clone, Debug, PartialEq)]
46pub struct OpenAiSettings {
47 pub api_url: String,
48 pub available_models: Vec<AvailableModel>,
49}
50
51pub struct OpenAiLanguageModelProvider {
52 http_client: Arc<dyn HttpClient>,
53 state: Entity<State>,
54}
55
56pub struct State {
57 api_key_state: ApiKeyState,
58}
59
60impl State {
61 fn is_authenticated(&self) -> bool {
62 self.api_key_state.has_key()
63 }
64
65 fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {
66 let api_url = OpenAiLanguageModelProvider::api_url(cx);
67 self.api_key_state
68 .store(api_url, api_key, |this| &mut this.api_key_state, cx)
69 }
70
71 fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
72 let api_url = OpenAiLanguageModelProvider::api_url(cx);
73 self.api_key_state
74 .load_if_needed(api_url, |this| &mut this.api_key_state, cx)
75 }
76}
77
78impl OpenAiLanguageModelProvider {
79 pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
80 let state = cx.new(|cx| {
81 cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
82 let api_url = Self::api_url(cx);
83 this.api_key_state
84 .handle_url_change(api_url, |this| &mut this.api_key_state, cx);
85 cx.notify();
86 })
87 .detach();
88 State {
89 api_key_state: ApiKeyState::new(Self::api_url(cx), (*API_KEY_ENV_VAR).clone()),
90 }
91 });
92
93 Self { http_client, state }
94 }
95
96 fn create_language_model(&self, model: open_ai::Model) -> Arc<dyn LanguageModel> {
97 Arc::new(OpenAiLanguageModel {
98 id: LanguageModelId::from(model.id().to_string()),
99 model,
100 state: self.state.clone(),
101 http_client: self.http_client.clone(),
102 request_limiter: RateLimiter::new(4),
103 })
104 }
105
106 fn settings(cx: &App) -> &OpenAiSettings {
107 &crate::AllLanguageModelSettings::get_global(cx).openai
108 }
109
110 fn api_url(cx: &App) -> SharedString {
111 let api_url = &Self::settings(cx).api_url;
112 if api_url.is_empty() {
113 open_ai::OPEN_AI_API_URL.into()
114 } else {
115 SharedString::new(api_url.as_str())
116 }
117 }
118}
119
120impl LanguageModelProviderState for OpenAiLanguageModelProvider {
121 type ObservableEntity = State;
122
123 fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
124 Some(self.state.clone())
125 }
126}
127
128impl LanguageModelProvider for OpenAiLanguageModelProvider {
129 fn id(&self) -> LanguageModelProviderId {
130 PROVIDER_ID
131 }
132
133 fn name(&self) -> LanguageModelProviderName {
134 PROVIDER_NAME
135 }
136
137 fn icon(&self) -> IconOrSvg {
138 IconOrSvg::Icon(IconName::AiOpenAi)
139 }
140
141 fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
142 Some(self.create_language_model(open_ai::Model::default()))
143 }
144
145 fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
146 Some(self.create_language_model(open_ai::Model::default_fast()))
147 }
148
149 fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
150 let mut models = BTreeMap::default();
151
152 // Add base models from open_ai::Model::iter()
153 for model in open_ai::Model::iter() {
154 if !matches!(model, open_ai::Model::Custom { .. }) {
155 models.insert(model.id().to_string(), model);
156 }
157 }
158
159 // Override with available models from settings
160 for model in &OpenAiLanguageModelProvider::settings(cx).available_models {
161 models.insert(
162 model.name.clone(),
163 open_ai::Model::Custom {
164 name: model.name.clone(),
165 display_name: model.display_name.clone(),
166 max_tokens: model.max_tokens,
167 max_output_tokens: model.max_output_tokens,
168 max_completion_tokens: model.max_completion_tokens,
169 reasoning_effort: model.reasoning_effort.clone(),
170 supports_chat_completions: model.capabilities.chat_completions,
171 },
172 );
173 }
174
175 models
176 .into_values()
177 .map(|model| self.create_language_model(model))
178 .collect()
179 }
180
181 fn is_authenticated(&self, cx: &App) -> bool {
182 self.state.read(cx).is_authenticated()
183 }
184
185 fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
186 self.state.update(cx, |state, cx| state.authenticate(cx))
187 }
188
189 fn configuration_view(
190 &self,
191 _target_agent: language_model::ConfigurationViewTargetAgent,
192 window: &mut Window,
193 cx: &mut App,
194 ) -> AnyView {
195 cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx))
196 .into()
197 }
198
199 fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {
200 self.state
201 .update(cx, |state, cx| state.set_api_key(None, cx))
202 }
203}
204
205pub struct OpenAiLanguageModel {
206 id: LanguageModelId,
207 model: open_ai::Model,
208 state: Entity<State>,
209 http_client: Arc<dyn HttpClient>,
210 request_limiter: RateLimiter,
211}
212
213impl OpenAiLanguageModel {
214 fn stream_completion(
215 &self,
216 request: open_ai::Request,
217 cx: &AsyncApp,
218 ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponseStreamEvent>>>>
219 {
220 let http_client = self.http_client.clone();
221
222 let (api_key, api_url) = self.state.read_with(cx, |state, cx| {
223 let api_url = OpenAiLanguageModelProvider::api_url(cx);
224 (state.api_key_state.key(&api_url), api_url)
225 });
226
227 let future = self.request_limiter.stream(async move {
228 let provider = PROVIDER_NAME;
229 let Some(api_key) = api_key else {
230 return Err(LanguageModelCompletionError::NoApiKey { provider });
231 };
232 let request = stream_completion(
233 http_client.as_ref(),
234 provider.0.as_str(),
235 &api_url,
236 &api_key,
237 request,
238 );
239 let response = request.await?;
240 Ok(response)
241 });
242
243 async move { Ok(future.await?.boxed()) }.boxed()
244 }
245
246 fn stream_response(
247 &self,
248 request: ResponseRequest,
249 cx: &AsyncApp,
250 ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponsesStreamEvent>>>>
251 {
252 let http_client = self.http_client.clone();
253
254 let (api_key, api_url) = self.state.read_with(cx, |state, cx| {
255 let api_url = OpenAiLanguageModelProvider::api_url(cx);
256 (state.api_key_state.key(&api_url), api_url)
257 });
258
259 let provider = PROVIDER_NAME;
260 let future = self.request_limiter.stream(async move {
261 let Some(api_key) = api_key else {
262 return Err(LanguageModelCompletionError::NoApiKey { provider });
263 };
264 let request = stream_response(
265 http_client.as_ref(),
266 provider.0.as_str(),
267 &api_url,
268 &api_key,
269 request,
270 );
271 let response = request.await?;
272 Ok(response)
273 });
274
275 async move { Ok(future.await?.boxed()) }.boxed()
276 }
277}
278
279impl LanguageModel for OpenAiLanguageModel {
280 fn id(&self) -> LanguageModelId {
281 self.id.clone()
282 }
283
284 fn name(&self) -> LanguageModelName {
285 LanguageModelName::from(self.model.display_name().to_string())
286 }
287
288 fn provider_id(&self) -> LanguageModelProviderId {
289 PROVIDER_ID
290 }
291
292 fn provider_name(&self) -> LanguageModelProviderName {
293 PROVIDER_NAME
294 }
295
296 fn supports_tools(&self) -> bool {
297 true
298 }
299
300 fn supports_images(&self) -> bool {
301 use open_ai::Model;
302 match &self.model {
303 Model::FourOmniMini
304 | Model::FourPointOneNano
305 | Model::Five
306 | Model::FiveCodex
307 | Model::FiveMini
308 | Model::FiveNano
309 | Model::FivePointOne
310 | Model::FivePointTwo
311 | Model::FivePointTwoCodex
312 | Model::FivePointThreeCodex
313 | Model::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 stop: request.stop,
510 temperature: request.temperature.or(Some(1.0)),
511 max_completion_tokens: max_output_tokens,
512 parallel_tool_calls: if supports_parallel_tool_calls && !request.tools.is_empty() {
513 // Disable parallel tool calls, as the Agent currently expects a maximum of one per turn.
514 Some(false)
515 } else {
516 None
517 },
518 prompt_cache_key: if supports_prompt_cache_key {
519 request.thread_id
520 } else {
521 None
522 },
523 tools: request
524 .tools
525 .into_iter()
526 .map(|tool| open_ai::ToolDefinition::Function {
527 function: open_ai::FunctionDefinition {
528 name: tool.name,
529 description: Some(tool.description),
530 parameters: Some(tool.input_schema),
531 },
532 })
533 .collect(),
534 tool_choice: request.tool_choice.map(|choice| match choice {
535 LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
536 LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
537 LanguageModelToolChoice::None => open_ai::ToolChoice::None,
538 }),
539 reasoning_effort,
540 }
541}
542
543pub fn into_open_ai_response(
544 request: LanguageModelRequest,
545 model_id: &str,
546 supports_parallel_tool_calls: bool,
547 supports_prompt_cache_key: bool,
548 max_output_tokens: Option<u64>,
549 reasoning_effort: Option<ReasoningEffort>,
550) -> ResponseRequest {
551 let stream = !model_id.starts_with("o1-");
552
553 let LanguageModelRequest {
554 thread_id,
555 prompt_id: _,
556 intent: _,
557 messages,
558 tools,
559 tool_choice,
560 stop: _,
561 temperature,
562 thinking_allowed: _,
563 thinking_effort: _,
564 speed: _,
565 } = request;
566
567 let mut input_items = Vec::new();
568 for (index, message) in messages.into_iter().enumerate() {
569 append_message_to_response_items(message, index, &mut input_items);
570 }
571
572 let tools: Vec<_> = tools
573 .into_iter()
574 .map(|tool| open_ai::responses::ToolDefinition::Function {
575 name: tool.name,
576 description: Some(tool.description),
577 parameters: Some(tool.input_schema),
578 strict: None,
579 })
580 .collect();
581
582 ResponseRequest {
583 model: model_id.into(),
584 input: input_items,
585 stream,
586 temperature,
587 top_p: None,
588 max_output_tokens,
589 parallel_tool_calls: if tools.is_empty() {
590 None
591 } else {
592 Some(supports_parallel_tool_calls)
593 },
594 tool_choice: tool_choice.map(|choice| match choice {
595 LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
596 LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
597 LanguageModelToolChoice::None => open_ai::ToolChoice::None,
598 }),
599 tools,
600 prompt_cache_key: if supports_prompt_cache_key {
601 thread_id
602 } else {
603 None
604 },
605 reasoning: reasoning_effort.map(|effort| open_ai::responses::ReasoningConfig {
606 effort,
607 summary: Some(open_ai::responses::ReasoningSummaryMode::Auto),
608 }),
609 }
610}
611
612fn append_message_to_response_items(
613 message: LanguageModelRequestMessage,
614 index: usize,
615 input_items: &mut Vec<ResponseInputItem>,
616) {
617 let mut content_parts: Vec<ResponseInputContent> = Vec::new();
618
619 for content in message.content {
620 match content {
621 MessageContent::Text(text) => {
622 push_response_text_part(&message.role, text, &mut content_parts);
623 }
624 MessageContent::Thinking { text, .. } => {
625 push_response_text_part(&message.role, text, &mut content_parts);
626 }
627 MessageContent::RedactedThinking(_) => {}
628 MessageContent::Image(image) => {
629 push_response_image_part(&message.role, image, &mut content_parts);
630 }
631 MessageContent::ToolUse(tool_use) => {
632 flush_response_parts(&message.role, index, &mut content_parts, input_items);
633 let call_id = tool_use.id.to_string();
634 input_items.push(ResponseInputItem::FunctionCall(ResponseFunctionCallItem {
635 call_id,
636 name: tool_use.name.to_string(),
637 arguments: tool_use.raw_input,
638 }));
639 }
640 MessageContent::ToolResult(tool_result) => {
641 flush_response_parts(&message.role, index, &mut content_parts, input_items);
642 input_items.push(ResponseInputItem::FunctionCallOutput(
643 ResponseFunctionCallOutputItem {
644 call_id: tool_result.tool_use_id.to_string(),
645 output: tool_result_output(&tool_result),
646 },
647 ));
648 }
649 }
650 }
651
652 flush_response_parts(&message.role, index, &mut content_parts, input_items);
653}
654
655fn push_response_text_part(
656 role: &Role,
657 text: impl Into<String>,
658 parts: &mut Vec<ResponseInputContent>,
659) {
660 let text = text.into();
661 if text.trim().is_empty() {
662 return;
663 }
664
665 match role {
666 Role::Assistant => parts.push(ResponseInputContent::OutputText {
667 text,
668 annotations: Vec::new(),
669 }),
670 _ => parts.push(ResponseInputContent::Text { text }),
671 }
672}
673
674fn push_response_image_part(
675 role: &Role,
676 image: LanguageModelImage,
677 parts: &mut Vec<ResponseInputContent>,
678) {
679 match role {
680 Role::Assistant => parts.push(ResponseInputContent::OutputText {
681 text: "[image omitted]".to_string(),
682 annotations: Vec::new(),
683 }),
684 _ => parts.push(ResponseInputContent::Image {
685 image_url: image.to_base64_url(),
686 }),
687 }
688}
689
690fn flush_response_parts(
691 role: &Role,
692 _index: usize,
693 parts: &mut Vec<ResponseInputContent>,
694 input_items: &mut Vec<ResponseInputItem>,
695) {
696 if parts.is_empty() {
697 return;
698 }
699
700 let item = ResponseInputItem::Message(ResponseMessageItem {
701 role: match role {
702 Role::User => open_ai::Role::User,
703 Role::Assistant => open_ai::Role::Assistant,
704 Role::System => open_ai::Role::System,
705 },
706 content: parts.clone(),
707 });
708
709 input_items.push(item);
710 parts.clear();
711}
712
713fn tool_result_output(result: &LanguageModelToolResult) -> String {
714 if let Some(output) = &result.output {
715 match output {
716 serde_json::Value::String(text) => text.clone(),
717 serde_json::Value::Null => String::new(),
718 _ => output.to_string(),
719 }
720 } else {
721 match &result.content {
722 LanguageModelToolResultContent::Text(text) => text.to_string(),
723 LanguageModelToolResultContent::Image(image) => image.to_base64_url(),
724 }
725 }
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 &partial_json_fixer::fix_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 &partial_json_fixer::fix_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::{LanguageModelRequestMessage, LanguageModelRequestTool};
1445 use open_ai::responses::{
1446 ReasoningSummaryPart, ResponseFunctionToolCall, ResponseOutputItem, ResponseOutputMessage,
1447 ResponseReasoningItem, ResponseStatusDetails, ResponseSummary, ResponseUsage,
1448 StreamEvent as ResponsesStreamEvent,
1449 };
1450 use pretty_assertions::assert_eq;
1451 use serde_json::json;
1452
1453 use super::*;
1454
1455 fn map_response_events(events: Vec<ResponsesStreamEvent>) -> Vec<LanguageModelCompletionEvent> {
1456 block_on(async {
1457 OpenAiResponseEventMapper::new()
1458 .map_stream(Box::pin(futures::stream::iter(events.into_iter().map(Ok))))
1459 .collect::<Vec<_>>()
1460 .await
1461 .into_iter()
1462 .map(Result::unwrap)
1463 .collect()
1464 })
1465 }
1466
1467 fn response_item_message(id: &str) -> ResponseOutputItem {
1468 ResponseOutputItem::Message(ResponseOutputMessage {
1469 id: Some(id.to_string()),
1470 role: Some("assistant".to_string()),
1471 status: Some("in_progress".to_string()),
1472 content: vec![],
1473 })
1474 }
1475
1476 fn response_item_function_call(id: &str, args: Option<&str>) -> ResponseOutputItem {
1477 ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
1478 id: Some(id.to_string()),
1479 status: Some("in_progress".to_string()),
1480 name: Some("get_weather".to_string()),
1481 call_id: Some("call_123".to_string()),
1482 arguments: args.map(|s| s.to_string()).unwrap_or_default(),
1483 })
1484 }
1485
1486 #[gpui::test]
1487 fn tiktoken_rs_support(cx: &TestAppContext) {
1488 let request = LanguageModelRequest {
1489 thread_id: None,
1490 prompt_id: None,
1491 intent: None,
1492 messages: vec![LanguageModelRequestMessage {
1493 role: Role::User,
1494 content: vec![MessageContent::Text("message".into())],
1495 cache: false,
1496 reasoning_details: None,
1497 }],
1498 tools: vec![],
1499 tool_choice: None,
1500 stop: vec![],
1501 temperature: None,
1502 thinking_allowed: true,
1503 thinking_effort: None,
1504 speed: None,
1505 };
1506
1507 // Validate that all models are supported by tiktoken-rs
1508 for model in Model::iter() {
1509 let count = cx
1510 .foreground_executor()
1511 .block_on(count_open_ai_tokens(
1512 request.clone(),
1513 model,
1514 &cx.app.borrow(),
1515 ))
1516 .unwrap();
1517 assert!(count > 0);
1518 }
1519 }
1520
1521 #[test]
1522 fn responses_stream_maps_text_and_usage() {
1523 let events = vec![
1524 ResponsesStreamEvent::OutputItemAdded {
1525 output_index: 0,
1526 sequence_number: None,
1527 item: response_item_message("msg_123"),
1528 },
1529 ResponsesStreamEvent::OutputTextDelta {
1530 item_id: "msg_123".into(),
1531 output_index: 0,
1532 content_index: Some(0),
1533 delta: "Hello".into(),
1534 },
1535 ResponsesStreamEvent::Completed {
1536 response: ResponseSummary {
1537 usage: Some(ResponseUsage {
1538 input_tokens: Some(5),
1539 output_tokens: Some(3),
1540 total_tokens: Some(8),
1541 }),
1542 ..Default::default()
1543 },
1544 },
1545 ];
1546
1547 let mapped = map_response_events(events);
1548 assert!(matches!(
1549 mapped[0],
1550 LanguageModelCompletionEvent::StartMessage { ref message_id } if message_id == "msg_123"
1551 ));
1552 assert!(matches!(
1553 mapped[1],
1554 LanguageModelCompletionEvent::Text(ref text) if text == "Hello"
1555 ));
1556 assert!(matches!(
1557 mapped[2],
1558 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1559 input_tokens: 5,
1560 output_tokens: 3,
1561 ..
1562 })
1563 ));
1564 assert!(matches!(
1565 mapped[3],
1566 LanguageModelCompletionEvent::Stop(StopReason::EndTurn)
1567 ));
1568 }
1569
1570 #[test]
1571 fn into_open_ai_response_builds_complete_payload() {
1572 let tool_call_id = LanguageModelToolUseId::from("call-42");
1573 let tool_input = json!({ "city": "Boston" });
1574 let tool_arguments = serde_json::to_string(&tool_input).unwrap();
1575 let tool_use = LanguageModelToolUse {
1576 id: tool_call_id.clone(),
1577 name: Arc::from("get_weather"),
1578 raw_input: tool_arguments.clone(),
1579 input: tool_input,
1580 is_input_complete: true,
1581 thought_signature: None,
1582 };
1583 let tool_result = LanguageModelToolResult {
1584 tool_use_id: tool_call_id,
1585 tool_name: Arc::from("get_weather"),
1586 is_error: false,
1587 content: LanguageModelToolResultContent::Text(Arc::from("Sunny")),
1588 output: Some(json!({ "forecast": "Sunny" })),
1589 };
1590 let user_image = LanguageModelImage {
1591 source: SharedString::from("aGVsbG8="),
1592 size: None,
1593 };
1594 let expected_image_url = user_image.to_base64_url();
1595
1596 let request = LanguageModelRequest {
1597 thread_id: Some("thread-123".into()),
1598 prompt_id: None,
1599 intent: None,
1600 messages: vec![
1601 LanguageModelRequestMessage {
1602 role: Role::System,
1603 content: vec![MessageContent::Text("System context".into())],
1604 cache: false,
1605 reasoning_details: None,
1606 },
1607 LanguageModelRequestMessage {
1608 role: Role::User,
1609 content: vec![
1610 MessageContent::Text("Please check the weather.".into()),
1611 MessageContent::Image(user_image),
1612 ],
1613 cache: false,
1614 reasoning_details: None,
1615 },
1616 LanguageModelRequestMessage {
1617 role: Role::Assistant,
1618 content: vec![
1619 MessageContent::Text("Looking that up.".into()),
1620 MessageContent::ToolUse(tool_use),
1621 ],
1622 cache: false,
1623 reasoning_details: None,
1624 },
1625 LanguageModelRequestMessage {
1626 role: Role::Assistant,
1627 content: vec![MessageContent::ToolResult(tool_result)],
1628 cache: false,
1629 reasoning_details: None,
1630 },
1631 ],
1632 tools: vec![LanguageModelRequestTool {
1633 name: "get_weather".into(),
1634 description: "Fetches the weather".into(),
1635 input_schema: json!({ "type": "object" }),
1636 use_input_streaming: false,
1637 }],
1638 tool_choice: Some(LanguageModelToolChoice::Any),
1639 stop: vec!["<STOP>".into()],
1640 temperature: None,
1641 thinking_allowed: false,
1642 thinking_effort: None,
1643 speed: None,
1644 };
1645
1646 let response = into_open_ai_response(
1647 request,
1648 "custom-model",
1649 true,
1650 true,
1651 Some(2048),
1652 Some(ReasoningEffort::Low),
1653 );
1654
1655 let serialized = serde_json::to_value(&response).unwrap();
1656 let expected = json!({
1657 "model": "custom-model",
1658 "input": [
1659 {
1660 "type": "message",
1661 "role": "system",
1662 "content": [
1663 { "type": "input_text", "text": "System context" }
1664 ]
1665 },
1666 {
1667 "type": "message",
1668 "role": "user",
1669 "content": [
1670 { "type": "input_text", "text": "Please check the weather." },
1671 { "type": "input_image", "image_url": expected_image_url }
1672 ]
1673 },
1674 {
1675 "type": "message",
1676 "role": "assistant",
1677 "content": [
1678 { "type": "output_text", "text": "Looking that up.", "annotations": [] }
1679 ]
1680 },
1681 {
1682 "type": "function_call",
1683 "call_id": "call-42",
1684 "name": "get_weather",
1685 "arguments": tool_arguments
1686 },
1687 {
1688 "type": "function_call_output",
1689 "call_id": "call-42",
1690 "output": "{\"forecast\":\"Sunny\"}"
1691 }
1692 ],
1693 "stream": true,
1694 "max_output_tokens": 2048,
1695 "parallel_tool_calls": true,
1696 "tool_choice": "required",
1697 "tools": [
1698 {
1699 "type": "function",
1700 "name": "get_weather",
1701 "description": "Fetches the weather",
1702 "parameters": { "type": "object" }
1703 }
1704 ],
1705 "prompt_cache_key": "thread-123",
1706 "reasoning": { "effort": "low", "summary": "auto" }
1707 });
1708
1709 assert_eq!(serialized, expected);
1710 }
1711
1712 #[test]
1713 fn responses_stream_maps_tool_calls() {
1714 let events = vec![
1715 ResponsesStreamEvent::OutputItemAdded {
1716 output_index: 0,
1717 sequence_number: None,
1718 item: response_item_function_call("item_fn", Some("{\"city\":\"Bos")),
1719 },
1720 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1721 item_id: "item_fn".into(),
1722 output_index: 0,
1723 delta: "ton\"}".into(),
1724 sequence_number: None,
1725 },
1726 ResponsesStreamEvent::FunctionCallArgumentsDone {
1727 item_id: "item_fn".into(),
1728 output_index: 0,
1729 arguments: "{\"city\":\"Boston\"}".into(),
1730 sequence_number: None,
1731 },
1732 ResponsesStreamEvent::Completed {
1733 response: ResponseSummary::default(),
1734 },
1735 ];
1736
1737 let mapped = map_response_events(events);
1738 assert_eq!(mapped.len(), 3);
1739 // First event is the partial tool use (from FunctionCallArgumentsDelta)
1740 assert!(matches!(
1741 mapped[0],
1742 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1743 is_input_complete: false,
1744 ..
1745 })
1746 ));
1747 // Second event is the complete tool use (from FunctionCallArgumentsDone)
1748 assert!(matches!(
1749 mapped[1],
1750 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1751 ref id,
1752 ref name,
1753 ref raw_input,
1754 is_input_complete: true,
1755 ..
1756 }) if id.to_string() == "call_123"
1757 && name.as_ref() == "get_weather"
1758 && raw_input == "{\"city\":\"Boston\"}"
1759 ));
1760 assert!(matches!(
1761 mapped[2],
1762 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1763 ));
1764 }
1765
1766 #[test]
1767 fn responses_stream_uses_max_tokens_stop_reason() {
1768 let events = vec![ResponsesStreamEvent::Incomplete {
1769 response: ResponseSummary {
1770 status_details: Some(ResponseStatusDetails {
1771 reason: Some("max_output_tokens".into()),
1772 r#type: Some("incomplete".into()),
1773 error: None,
1774 }),
1775 usage: Some(ResponseUsage {
1776 input_tokens: Some(10),
1777 output_tokens: Some(20),
1778 total_tokens: Some(30),
1779 }),
1780 ..Default::default()
1781 },
1782 }];
1783
1784 let mapped = map_response_events(events);
1785 assert!(matches!(
1786 mapped[0],
1787 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1788 input_tokens: 10,
1789 output_tokens: 20,
1790 ..
1791 })
1792 ));
1793 assert!(matches!(
1794 mapped[1],
1795 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1796 ));
1797 }
1798
1799 #[test]
1800 fn responses_stream_handles_multiple_tool_calls() {
1801 let events = vec![
1802 ResponsesStreamEvent::OutputItemAdded {
1803 output_index: 0,
1804 sequence_number: None,
1805 item: response_item_function_call("item_fn1", Some("{\"city\":\"NYC\"}")),
1806 },
1807 ResponsesStreamEvent::FunctionCallArgumentsDone {
1808 item_id: "item_fn1".into(),
1809 output_index: 0,
1810 arguments: "{\"city\":\"NYC\"}".into(),
1811 sequence_number: None,
1812 },
1813 ResponsesStreamEvent::OutputItemAdded {
1814 output_index: 1,
1815 sequence_number: None,
1816 item: response_item_function_call("item_fn2", Some("{\"city\":\"LA\"}")),
1817 },
1818 ResponsesStreamEvent::FunctionCallArgumentsDone {
1819 item_id: "item_fn2".into(),
1820 output_index: 1,
1821 arguments: "{\"city\":\"LA\"}".into(),
1822 sequence_number: None,
1823 },
1824 ResponsesStreamEvent::Completed {
1825 response: ResponseSummary::default(),
1826 },
1827 ];
1828
1829 let mapped = map_response_events(events);
1830 assert_eq!(mapped.len(), 3);
1831 assert!(matches!(
1832 mapped[0],
1833 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1834 if raw_input == "{\"city\":\"NYC\"}"
1835 ));
1836 assert!(matches!(
1837 mapped[1],
1838 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1839 if raw_input == "{\"city\":\"LA\"}"
1840 ));
1841 assert!(matches!(
1842 mapped[2],
1843 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1844 ));
1845 }
1846
1847 #[test]
1848 fn responses_stream_handles_mixed_text_and_tool_calls() {
1849 let events = vec![
1850 ResponsesStreamEvent::OutputItemAdded {
1851 output_index: 0,
1852 sequence_number: None,
1853 item: response_item_message("msg_123"),
1854 },
1855 ResponsesStreamEvent::OutputTextDelta {
1856 item_id: "msg_123".into(),
1857 output_index: 0,
1858 content_index: Some(0),
1859 delta: "Let me check that".into(),
1860 },
1861 ResponsesStreamEvent::OutputItemAdded {
1862 output_index: 1,
1863 sequence_number: None,
1864 item: response_item_function_call("item_fn", Some("{\"query\":\"test\"}")),
1865 },
1866 ResponsesStreamEvent::FunctionCallArgumentsDone {
1867 item_id: "item_fn".into(),
1868 output_index: 1,
1869 arguments: "{\"query\":\"test\"}".into(),
1870 sequence_number: None,
1871 },
1872 ResponsesStreamEvent::Completed {
1873 response: ResponseSummary::default(),
1874 },
1875 ];
1876
1877 let mapped = map_response_events(events);
1878 assert!(matches!(
1879 mapped[0],
1880 LanguageModelCompletionEvent::StartMessage { .. }
1881 ));
1882 assert!(matches!(
1883 mapped[1],
1884 LanguageModelCompletionEvent::Text(ref text) if text == "Let me check that"
1885 ));
1886 assert!(matches!(
1887 mapped[2],
1888 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1889 if raw_input == "{\"query\":\"test\"}"
1890 ));
1891 assert!(matches!(
1892 mapped[3],
1893 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1894 ));
1895 }
1896
1897 #[test]
1898 fn responses_stream_handles_json_parse_error() {
1899 let events = vec![
1900 ResponsesStreamEvent::OutputItemAdded {
1901 output_index: 0,
1902 sequence_number: None,
1903 item: response_item_function_call("item_fn", Some("{invalid json")),
1904 },
1905 ResponsesStreamEvent::FunctionCallArgumentsDone {
1906 item_id: "item_fn".into(),
1907 output_index: 0,
1908 arguments: "{invalid json".into(),
1909 sequence_number: None,
1910 },
1911 ResponsesStreamEvent::Completed {
1912 response: ResponseSummary::default(),
1913 },
1914 ];
1915
1916 let mapped = map_response_events(events);
1917 assert!(matches!(
1918 mapped[0],
1919 LanguageModelCompletionEvent::ToolUseJsonParseError {
1920 ref raw_input,
1921 ..
1922 } if raw_input.as_ref() == "{invalid json"
1923 ));
1924 }
1925
1926 #[test]
1927 fn responses_stream_handles_incomplete_function_call() {
1928 let events = vec![
1929 ResponsesStreamEvent::OutputItemAdded {
1930 output_index: 0,
1931 sequence_number: None,
1932 item: response_item_function_call("item_fn", Some("{\"city\":")),
1933 },
1934 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1935 item_id: "item_fn".into(),
1936 output_index: 0,
1937 delta: "\"Boston\"".into(),
1938 sequence_number: None,
1939 },
1940 ResponsesStreamEvent::Incomplete {
1941 response: ResponseSummary {
1942 status_details: Some(ResponseStatusDetails {
1943 reason: Some("max_output_tokens".into()),
1944 r#type: Some("incomplete".into()),
1945 error: None,
1946 }),
1947 output: vec![response_item_function_call(
1948 "item_fn",
1949 Some("{\"city\":\"Boston\"}"),
1950 )],
1951 ..Default::default()
1952 },
1953 },
1954 ];
1955
1956 let mapped = map_response_events(events);
1957 assert_eq!(mapped.len(), 3);
1958 // First event is the partial tool use (from FunctionCallArgumentsDelta)
1959 assert!(matches!(
1960 mapped[0],
1961 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1962 is_input_complete: false,
1963 ..
1964 })
1965 ));
1966 // Second event is the complete tool use (from the Incomplete response output)
1967 assert!(matches!(
1968 mapped[1],
1969 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1970 ref raw_input,
1971 is_input_complete: true,
1972 ..
1973 })
1974 if raw_input == "{\"city\":\"Boston\"}"
1975 ));
1976 assert!(matches!(
1977 mapped[2],
1978 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1979 ));
1980 }
1981
1982 #[test]
1983 fn responses_stream_incomplete_does_not_duplicate_tool_calls() {
1984 let events = vec![
1985 ResponsesStreamEvent::OutputItemAdded {
1986 output_index: 0,
1987 sequence_number: None,
1988 item: response_item_function_call("item_fn", Some("{\"city\":\"Boston\"}")),
1989 },
1990 ResponsesStreamEvent::FunctionCallArgumentsDone {
1991 item_id: "item_fn".into(),
1992 output_index: 0,
1993 arguments: "{\"city\":\"Boston\"}".into(),
1994 sequence_number: None,
1995 },
1996 ResponsesStreamEvent::Incomplete {
1997 response: ResponseSummary {
1998 status_details: Some(ResponseStatusDetails {
1999 reason: Some("max_output_tokens".into()),
2000 r#type: Some("incomplete".into()),
2001 error: None,
2002 }),
2003 output: vec![response_item_function_call(
2004 "item_fn",
2005 Some("{\"city\":\"Boston\"}"),
2006 )],
2007 ..Default::default()
2008 },
2009 },
2010 ];
2011
2012 let mapped = map_response_events(events);
2013 assert_eq!(mapped.len(), 2);
2014 assert!(matches!(
2015 mapped[0],
2016 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
2017 if raw_input == "{\"city\":\"Boston\"}"
2018 ));
2019 assert!(matches!(
2020 mapped[1],
2021 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
2022 ));
2023 }
2024
2025 #[test]
2026 fn responses_stream_handles_empty_tool_arguments() {
2027 // Test that tools with no arguments (empty string) are handled correctly
2028 let events = vec![
2029 ResponsesStreamEvent::OutputItemAdded {
2030 output_index: 0,
2031 sequence_number: None,
2032 item: response_item_function_call("item_fn", Some("")),
2033 },
2034 ResponsesStreamEvent::FunctionCallArgumentsDone {
2035 item_id: "item_fn".into(),
2036 output_index: 0,
2037 arguments: "".into(),
2038 sequence_number: None,
2039 },
2040 ResponsesStreamEvent::Completed {
2041 response: ResponseSummary::default(),
2042 },
2043 ];
2044
2045 let mapped = map_response_events(events);
2046 assert_eq!(mapped.len(), 2);
2047
2048 // Should produce a ToolUse event with an empty object
2049 assert!(matches!(
2050 &mapped[0],
2051 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2052 id,
2053 name,
2054 raw_input,
2055 input,
2056 ..
2057 }) if id.to_string() == "call_123"
2058 && name.as_ref() == "get_weather"
2059 && raw_input == ""
2060 && input.is_object()
2061 && input.as_object().unwrap().is_empty()
2062 ));
2063
2064 assert!(matches!(
2065 mapped[1],
2066 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
2067 ));
2068 }
2069
2070 #[test]
2071 fn responses_stream_emits_partial_tool_use_events() {
2072 let events = vec![
2073 ResponsesStreamEvent::OutputItemAdded {
2074 output_index: 0,
2075 sequence_number: None,
2076 item: ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
2077 id: Some("item_fn".to_string()),
2078 status: Some("in_progress".to_string()),
2079 name: Some("get_weather".to_string()),
2080 call_id: Some("call_abc".to_string()),
2081 arguments: String::new(),
2082 }),
2083 },
2084 ResponsesStreamEvent::FunctionCallArgumentsDelta {
2085 item_id: "item_fn".into(),
2086 output_index: 0,
2087 delta: "{\"city\":\"Bos".into(),
2088 sequence_number: None,
2089 },
2090 ResponsesStreamEvent::FunctionCallArgumentsDelta {
2091 item_id: "item_fn".into(),
2092 output_index: 0,
2093 delta: "ton\"}".into(),
2094 sequence_number: None,
2095 },
2096 ResponsesStreamEvent::FunctionCallArgumentsDone {
2097 item_id: "item_fn".into(),
2098 output_index: 0,
2099 arguments: "{\"city\":\"Boston\"}".into(),
2100 sequence_number: None,
2101 },
2102 ResponsesStreamEvent::Completed {
2103 response: ResponseSummary::default(),
2104 },
2105 ];
2106
2107 let mapped = map_response_events(events);
2108 // Two partial events + one complete event + Stop
2109 assert!(mapped.len() >= 3);
2110
2111 // The last complete ToolUse event should have is_input_complete: true
2112 let complete_tool_use = mapped.iter().find(|e| {
2113 matches!(
2114 e,
2115 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2116 is_input_complete: true,
2117 ..
2118 })
2119 )
2120 });
2121 assert!(
2122 complete_tool_use.is_some(),
2123 "should have a complete tool use event"
2124 );
2125
2126 // All ToolUse events before the final one should have is_input_complete: false
2127 let tool_uses: Vec<_> = mapped
2128 .iter()
2129 .filter(|e| matches!(e, LanguageModelCompletionEvent::ToolUse(_)))
2130 .collect();
2131 assert!(
2132 tool_uses.len() >= 2,
2133 "should have at least one partial and one complete event"
2134 );
2135
2136 let last = tool_uses.last().unwrap();
2137 assert!(matches!(
2138 last,
2139 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2140 is_input_complete: true,
2141 ..
2142 })
2143 ));
2144 }
2145
2146 #[test]
2147 fn responses_stream_maps_reasoning_summary_deltas() {
2148 let events = vec![
2149 ResponsesStreamEvent::OutputItemAdded {
2150 output_index: 0,
2151 sequence_number: None,
2152 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2153 id: Some("rs_123".into()),
2154 summary: vec![],
2155 }),
2156 },
2157 ResponsesStreamEvent::ReasoningSummaryPartAdded {
2158 item_id: "rs_123".into(),
2159 output_index: 0,
2160 summary_index: 0,
2161 },
2162 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2163 item_id: "rs_123".into(),
2164 output_index: 0,
2165 delta: "Thinking about".into(),
2166 },
2167 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2168 item_id: "rs_123".into(),
2169 output_index: 0,
2170 delta: " the answer".into(),
2171 },
2172 ResponsesStreamEvent::ReasoningSummaryTextDone {
2173 item_id: "rs_123".into(),
2174 output_index: 0,
2175 text: "Thinking about the answer".into(),
2176 },
2177 ResponsesStreamEvent::ReasoningSummaryPartDone {
2178 item_id: "rs_123".into(),
2179 output_index: 0,
2180 summary_index: 0,
2181 },
2182 ResponsesStreamEvent::ReasoningSummaryPartAdded {
2183 item_id: "rs_123".into(),
2184 output_index: 0,
2185 summary_index: 1,
2186 },
2187 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2188 item_id: "rs_123".into(),
2189 output_index: 0,
2190 delta: "Second part".into(),
2191 },
2192 ResponsesStreamEvent::ReasoningSummaryTextDone {
2193 item_id: "rs_123".into(),
2194 output_index: 0,
2195 text: "Second part".into(),
2196 },
2197 ResponsesStreamEvent::ReasoningSummaryPartDone {
2198 item_id: "rs_123".into(),
2199 output_index: 0,
2200 summary_index: 1,
2201 },
2202 ResponsesStreamEvent::OutputItemDone {
2203 output_index: 0,
2204 sequence_number: None,
2205 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2206 id: Some("rs_123".into()),
2207 summary: vec![
2208 ReasoningSummaryPart::SummaryText {
2209 text: "Thinking about the answer".into(),
2210 },
2211 ReasoningSummaryPart::SummaryText {
2212 text: "Second part".into(),
2213 },
2214 ],
2215 }),
2216 },
2217 ResponsesStreamEvent::OutputItemAdded {
2218 output_index: 1,
2219 sequence_number: None,
2220 item: response_item_message("msg_456"),
2221 },
2222 ResponsesStreamEvent::OutputTextDelta {
2223 item_id: "msg_456".into(),
2224 output_index: 1,
2225 content_index: Some(0),
2226 delta: "The answer is 42".into(),
2227 },
2228 ResponsesStreamEvent::Completed {
2229 response: ResponseSummary::default(),
2230 },
2231 ];
2232
2233 let mapped = map_response_events(events);
2234
2235 let thinking_events: Vec<_> = mapped
2236 .iter()
2237 .filter(|e| matches!(e, LanguageModelCompletionEvent::Thinking { .. }))
2238 .collect();
2239 assert_eq!(
2240 thinking_events.len(),
2241 4,
2242 "expected 4 thinking events (2 deltas + separator + second delta), got {:?}",
2243 thinking_events,
2244 );
2245
2246 assert!(matches!(
2247 &thinking_events[0],
2248 LanguageModelCompletionEvent::Thinking { text, .. } if text == "Thinking about"
2249 ));
2250 assert!(matches!(
2251 &thinking_events[1],
2252 LanguageModelCompletionEvent::Thinking { text, .. } if text == " the answer"
2253 ));
2254 assert!(
2255 matches!(
2256 &thinking_events[2],
2257 LanguageModelCompletionEvent::Thinking { text, .. } if text == "\n\n"
2258 ),
2259 "expected separator between summary parts"
2260 );
2261 assert!(matches!(
2262 &thinking_events[3],
2263 LanguageModelCompletionEvent::Thinking { text, .. } if text == "Second part"
2264 ));
2265
2266 assert!(mapped.iter().any(|e| matches!(
2267 e,
2268 LanguageModelCompletionEvent::Text(t) if t == "The answer is 42"
2269 )));
2270 }
2271
2272 #[test]
2273 fn responses_stream_maps_reasoning_from_done_only() {
2274 let events = vec![
2275 ResponsesStreamEvent::OutputItemAdded {
2276 output_index: 0,
2277 sequence_number: None,
2278 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2279 id: Some("rs_789".into()),
2280 summary: vec![],
2281 }),
2282 },
2283 ResponsesStreamEvent::OutputItemDone {
2284 output_index: 0,
2285 sequence_number: None,
2286 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2287 id: Some("rs_789".into()),
2288 summary: vec![ReasoningSummaryPart::SummaryText {
2289 text: "Summary without deltas".into(),
2290 }],
2291 }),
2292 },
2293 ResponsesStreamEvent::Completed {
2294 response: ResponseSummary::default(),
2295 },
2296 ];
2297
2298 let mapped = map_response_events(events);
2299
2300 assert!(
2301 !mapped
2302 .iter()
2303 .any(|e| matches!(e, LanguageModelCompletionEvent::Thinking { .. })),
2304 "OutputItemDone reasoning should not produce Thinking events (no delta/done text events)"
2305 );
2306 }
2307}