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 .icon(IconName::ArrowUpRight)
1419 .icon_size(IconSize::Small)
1420 .icon_color(Color::Muted)
1421 .on_click(move |_, _window, cx| {
1422 cx.open_url("https://zed.dev/docs/ai/llm-providers#openai-api-compatible")
1423 }),
1424 );
1425
1426 if self.load_credentials_task.is_some() {
1427 div().child(Label::new("Loading credentials…")).into_any()
1428 } else {
1429 v_flex()
1430 .size_full()
1431 .child(api_key_section)
1432 .child(compatible_api_section)
1433 .into_any()
1434 }
1435 }
1436}
1437
1438#[cfg(test)]
1439mod tests {
1440 use futures::{StreamExt, executor::block_on};
1441 use gpui::TestAppContext;
1442 use language_model::{LanguageModelRequestMessage, LanguageModelRequestTool};
1443 use open_ai::responses::{
1444 ReasoningSummaryPart, ResponseFunctionToolCall, ResponseOutputItem, ResponseOutputMessage,
1445 ResponseReasoningItem, ResponseStatusDetails, ResponseSummary, ResponseUsage,
1446 StreamEvent as ResponsesStreamEvent,
1447 };
1448 use pretty_assertions::assert_eq;
1449 use serde_json::json;
1450
1451 use super::*;
1452
1453 fn map_response_events(events: Vec<ResponsesStreamEvent>) -> Vec<LanguageModelCompletionEvent> {
1454 block_on(async {
1455 OpenAiResponseEventMapper::new()
1456 .map_stream(Box::pin(futures::stream::iter(events.into_iter().map(Ok))))
1457 .collect::<Vec<_>>()
1458 .await
1459 .into_iter()
1460 .map(Result::unwrap)
1461 .collect()
1462 })
1463 }
1464
1465 fn response_item_message(id: &str) -> ResponseOutputItem {
1466 ResponseOutputItem::Message(ResponseOutputMessage {
1467 id: Some(id.to_string()),
1468 role: Some("assistant".to_string()),
1469 status: Some("in_progress".to_string()),
1470 content: vec![],
1471 })
1472 }
1473
1474 fn response_item_function_call(id: &str, args: Option<&str>) -> ResponseOutputItem {
1475 ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
1476 id: Some(id.to_string()),
1477 status: Some("in_progress".to_string()),
1478 name: Some("get_weather".to_string()),
1479 call_id: Some("call_123".to_string()),
1480 arguments: args.map(|s| s.to_string()).unwrap_or_default(),
1481 })
1482 }
1483
1484 #[gpui::test]
1485 fn tiktoken_rs_support(cx: &TestAppContext) {
1486 let request = LanguageModelRequest {
1487 thread_id: None,
1488 prompt_id: None,
1489 intent: None,
1490 messages: vec![LanguageModelRequestMessage {
1491 role: Role::User,
1492 content: vec![MessageContent::Text("message".into())],
1493 cache: false,
1494 reasoning_details: None,
1495 }],
1496 tools: vec![],
1497 tool_choice: None,
1498 stop: vec![],
1499 temperature: None,
1500 thinking_allowed: true,
1501 thinking_effort: None,
1502 speed: None,
1503 };
1504
1505 // Validate that all models are supported by tiktoken-rs
1506 for model in Model::iter() {
1507 let count = cx
1508 .foreground_executor()
1509 .block_on(count_open_ai_tokens(
1510 request.clone(),
1511 model,
1512 &cx.app.borrow(),
1513 ))
1514 .unwrap();
1515 assert!(count > 0);
1516 }
1517 }
1518
1519 #[test]
1520 fn responses_stream_maps_text_and_usage() {
1521 let events = vec![
1522 ResponsesStreamEvent::OutputItemAdded {
1523 output_index: 0,
1524 sequence_number: None,
1525 item: response_item_message("msg_123"),
1526 },
1527 ResponsesStreamEvent::OutputTextDelta {
1528 item_id: "msg_123".into(),
1529 output_index: 0,
1530 content_index: Some(0),
1531 delta: "Hello".into(),
1532 },
1533 ResponsesStreamEvent::Completed {
1534 response: ResponseSummary {
1535 usage: Some(ResponseUsage {
1536 input_tokens: Some(5),
1537 output_tokens: Some(3),
1538 total_tokens: Some(8),
1539 }),
1540 ..Default::default()
1541 },
1542 },
1543 ];
1544
1545 let mapped = map_response_events(events);
1546 assert!(matches!(
1547 mapped[0],
1548 LanguageModelCompletionEvent::StartMessage { ref message_id } if message_id == "msg_123"
1549 ));
1550 assert!(matches!(
1551 mapped[1],
1552 LanguageModelCompletionEvent::Text(ref text) if text == "Hello"
1553 ));
1554 assert!(matches!(
1555 mapped[2],
1556 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1557 input_tokens: 5,
1558 output_tokens: 3,
1559 ..
1560 })
1561 ));
1562 assert!(matches!(
1563 mapped[3],
1564 LanguageModelCompletionEvent::Stop(StopReason::EndTurn)
1565 ));
1566 }
1567
1568 #[test]
1569 fn into_open_ai_response_builds_complete_payload() {
1570 let tool_call_id = LanguageModelToolUseId::from("call-42");
1571 let tool_input = json!({ "city": "Boston" });
1572 let tool_arguments = serde_json::to_string(&tool_input).unwrap();
1573 let tool_use = LanguageModelToolUse {
1574 id: tool_call_id.clone(),
1575 name: Arc::from("get_weather"),
1576 raw_input: tool_arguments.clone(),
1577 input: tool_input,
1578 is_input_complete: true,
1579 thought_signature: None,
1580 };
1581 let tool_result = LanguageModelToolResult {
1582 tool_use_id: tool_call_id,
1583 tool_name: Arc::from("get_weather"),
1584 is_error: false,
1585 content: LanguageModelToolResultContent::Text(Arc::from("Sunny")),
1586 output: Some(json!({ "forecast": "Sunny" })),
1587 };
1588 let user_image = LanguageModelImage {
1589 source: SharedString::from("aGVsbG8="),
1590 size: None,
1591 };
1592 let expected_image_url = user_image.to_base64_url();
1593
1594 let request = LanguageModelRequest {
1595 thread_id: Some("thread-123".into()),
1596 prompt_id: None,
1597 intent: None,
1598 messages: vec![
1599 LanguageModelRequestMessage {
1600 role: Role::System,
1601 content: vec![MessageContent::Text("System context".into())],
1602 cache: false,
1603 reasoning_details: None,
1604 },
1605 LanguageModelRequestMessage {
1606 role: Role::User,
1607 content: vec![
1608 MessageContent::Text("Please check the weather.".into()),
1609 MessageContent::Image(user_image),
1610 ],
1611 cache: false,
1612 reasoning_details: None,
1613 },
1614 LanguageModelRequestMessage {
1615 role: Role::Assistant,
1616 content: vec![
1617 MessageContent::Text("Looking that up.".into()),
1618 MessageContent::ToolUse(tool_use),
1619 ],
1620 cache: false,
1621 reasoning_details: None,
1622 },
1623 LanguageModelRequestMessage {
1624 role: Role::Assistant,
1625 content: vec![MessageContent::ToolResult(tool_result)],
1626 cache: false,
1627 reasoning_details: None,
1628 },
1629 ],
1630 tools: vec![LanguageModelRequestTool {
1631 name: "get_weather".into(),
1632 description: "Fetches the weather".into(),
1633 input_schema: json!({ "type": "object" }),
1634 use_input_streaming: false,
1635 }],
1636 tool_choice: Some(LanguageModelToolChoice::Any),
1637 stop: vec!["<STOP>".into()],
1638 temperature: None,
1639 thinking_allowed: false,
1640 thinking_effort: None,
1641 speed: None,
1642 };
1643
1644 let response = into_open_ai_response(
1645 request,
1646 "custom-model",
1647 true,
1648 true,
1649 Some(2048),
1650 Some(ReasoningEffort::Low),
1651 );
1652
1653 let serialized = serde_json::to_value(&response).unwrap();
1654 let expected = json!({
1655 "model": "custom-model",
1656 "input": [
1657 {
1658 "type": "message",
1659 "role": "system",
1660 "content": [
1661 { "type": "input_text", "text": "System context" }
1662 ]
1663 },
1664 {
1665 "type": "message",
1666 "role": "user",
1667 "content": [
1668 { "type": "input_text", "text": "Please check the weather." },
1669 { "type": "input_image", "image_url": expected_image_url }
1670 ]
1671 },
1672 {
1673 "type": "message",
1674 "role": "assistant",
1675 "content": [
1676 { "type": "output_text", "text": "Looking that up.", "annotations": [] }
1677 ]
1678 },
1679 {
1680 "type": "function_call",
1681 "call_id": "call-42",
1682 "name": "get_weather",
1683 "arguments": tool_arguments
1684 },
1685 {
1686 "type": "function_call_output",
1687 "call_id": "call-42",
1688 "output": "{\"forecast\":\"Sunny\"}"
1689 }
1690 ],
1691 "stream": true,
1692 "max_output_tokens": 2048,
1693 "parallel_tool_calls": true,
1694 "tool_choice": "required",
1695 "tools": [
1696 {
1697 "type": "function",
1698 "name": "get_weather",
1699 "description": "Fetches the weather",
1700 "parameters": { "type": "object" }
1701 }
1702 ],
1703 "prompt_cache_key": "thread-123",
1704 "reasoning": { "effort": "low", "summary": "auto" }
1705 });
1706
1707 assert_eq!(serialized, expected);
1708 }
1709
1710 #[test]
1711 fn responses_stream_maps_tool_calls() {
1712 let events = vec![
1713 ResponsesStreamEvent::OutputItemAdded {
1714 output_index: 0,
1715 sequence_number: None,
1716 item: response_item_function_call("item_fn", Some("{\"city\":\"Bos")),
1717 },
1718 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1719 item_id: "item_fn".into(),
1720 output_index: 0,
1721 delta: "ton\"}".into(),
1722 sequence_number: None,
1723 },
1724 ResponsesStreamEvent::FunctionCallArgumentsDone {
1725 item_id: "item_fn".into(),
1726 output_index: 0,
1727 arguments: "{\"city\":\"Boston\"}".into(),
1728 sequence_number: None,
1729 },
1730 ResponsesStreamEvent::Completed {
1731 response: ResponseSummary::default(),
1732 },
1733 ];
1734
1735 let mapped = map_response_events(events);
1736 assert_eq!(mapped.len(), 3);
1737 // First event is the partial tool use (from FunctionCallArgumentsDelta)
1738 assert!(matches!(
1739 mapped[0],
1740 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1741 is_input_complete: false,
1742 ..
1743 })
1744 ));
1745 // Second event is the complete tool use (from FunctionCallArgumentsDone)
1746 assert!(matches!(
1747 mapped[1],
1748 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1749 ref id,
1750 ref name,
1751 ref raw_input,
1752 is_input_complete: true,
1753 ..
1754 }) if id.to_string() == "call_123"
1755 && name.as_ref() == "get_weather"
1756 && raw_input == "{\"city\":\"Boston\"}"
1757 ));
1758 assert!(matches!(
1759 mapped[2],
1760 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1761 ));
1762 }
1763
1764 #[test]
1765 fn responses_stream_uses_max_tokens_stop_reason() {
1766 let events = vec![ResponsesStreamEvent::Incomplete {
1767 response: ResponseSummary {
1768 status_details: Some(ResponseStatusDetails {
1769 reason: Some("max_output_tokens".into()),
1770 r#type: Some("incomplete".into()),
1771 error: None,
1772 }),
1773 usage: Some(ResponseUsage {
1774 input_tokens: Some(10),
1775 output_tokens: Some(20),
1776 total_tokens: Some(30),
1777 }),
1778 ..Default::default()
1779 },
1780 }];
1781
1782 let mapped = map_response_events(events);
1783 assert!(matches!(
1784 mapped[0],
1785 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1786 input_tokens: 10,
1787 output_tokens: 20,
1788 ..
1789 })
1790 ));
1791 assert!(matches!(
1792 mapped[1],
1793 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1794 ));
1795 }
1796
1797 #[test]
1798 fn responses_stream_handles_multiple_tool_calls() {
1799 let events = vec![
1800 ResponsesStreamEvent::OutputItemAdded {
1801 output_index: 0,
1802 sequence_number: None,
1803 item: response_item_function_call("item_fn1", Some("{\"city\":\"NYC\"}")),
1804 },
1805 ResponsesStreamEvent::FunctionCallArgumentsDone {
1806 item_id: "item_fn1".into(),
1807 output_index: 0,
1808 arguments: "{\"city\":\"NYC\"}".into(),
1809 sequence_number: None,
1810 },
1811 ResponsesStreamEvent::OutputItemAdded {
1812 output_index: 1,
1813 sequence_number: None,
1814 item: response_item_function_call("item_fn2", Some("{\"city\":\"LA\"}")),
1815 },
1816 ResponsesStreamEvent::FunctionCallArgumentsDone {
1817 item_id: "item_fn2".into(),
1818 output_index: 1,
1819 arguments: "{\"city\":\"LA\"}".into(),
1820 sequence_number: None,
1821 },
1822 ResponsesStreamEvent::Completed {
1823 response: ResponseSummary::default(),
1824 },
1825 ];
1826
1827 let mapped = map_response_events(events);
1828 assert_eq!(mapped.len(), 3);
1829 assert!(matches!(
1830 mapped[0],
1831 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1832 if raw_input == "{\"city\":\"NYC\"}"
1833 ));
1834 assert!(matches!(
1835 mapped[1],
1836 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1837 if raw_input == "{\"city\":\"LA\"}"
1838 ));
1839 assert!(matches!(
1840 mapped[2],
1841 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1842 ));
1843 }
1844
1845 #[test]
1846 fn responses_stream_handles_mixed_text_and_tool_calls() {
1847 let events = vec![
1848 ResponsesStreamEvent::OutputItemAdded {
1849 output_index: 0,
1850 sequence_number: None,
1851 item: response_item_message("msg_123"),
1852 },
1853 ResponsesStreamEvent::OutputTextDelta {
1854 item_id: "msg_123".into(),
1855 output_index: 0,
1856 content_index: Some(0),
1857 delta: "Let me check that".into(),
1858 },
1859 ResponsesStreamEvent::OutputItemAdded {
1860 output_index: 1,
1861 sequence_number: None,
1862 item: response_item_function_call("item_fn", Some("{\"query\":\"test\"}")),
1863 },
1864 ResponsesStreamEvent::FunctionCallArgumentsDone {
1865 item_id: "item_fn".into(),
1866 output_index: 1,
1867 arguments: "{\"query\":\"test\"}".into(),
1868 sequence_number: None,
1869 },
1870 ResponsesStreamEvent::Completed {
1871 response: ResponseSummary::default(),
1872 },
1873 ];
1874
1875 let mapped = map_response_events(events);
1876 assert!(matches!(
1877 mapped[0],
1878 LanguageModelCompletionEvent::StartMessage { .. }
1879 ));
1880 assert!(matches!(
1881 mapped[1],
1882 LanguageModelCompletionEvent::Text(ref text) if text == "Let me check that"
1883 ));
1884 assert!(matches!(
1885 mapped[2],
1886 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1887 if raw_input == "{\"query\":\"test\"}"
1888 ));
1889 assert!(matches!(
1890 mapped[3],
1891 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1892 ));
1893 }
1894
1895 #[test]
1896 fn responses_stream_handles_json_parse_error() {
1897 let events = vec![
1898 ResponsesStreamEvent::OutputItemAdded {
1899 output_index: 0,
1900 sequence_number: None,
1901 item: response_item_function_call("item_fn", Some("{invalid json")),
1902 },
1903 ResponsesStreamEvent::FunctionCallArgumentsDone {
1904 item_id: "item_fn".into(),
1905 output_index: 0,
1906 arguments: "{invalid json".into(),
1907 sequence_number: None,
1908 },
1909 ResponsesStreamEvent::Completed {
1910 response: ResponseSummary::default(),
1911 },
1912 ];
1913
1914 let mapped = map_response_events(events);
1915 assert!(matches!(
1916 mapped[0],
1917 LanguageModelCompletionEvent::ToolUseJsonParseError {
1918 ref raw_input,
1919 ..
1920 } if raw_input.as_ref() == "{invalid json"
1921 ));
1922 }
1923
1924 #[test]
1925 fn responses_stream_handles_incomplete_function_call() {
1926 let events = vec![
1927 ResponsesStreamEvent::OutputItemAdded {
1928 output_index: 0,
1929 sequence_number: None,
1930 item: response_item_function_call("item_fn", Some("{\"city\":")),
1931 },
1932 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1933 item_id: "item_fn".into(),
1934 output_index: 0,
1935 delta: "\"Boston\"".into(),
1936 sequence_number: None,
1937 },
1938 ResponsesStreamEvent::Incomplete {
1939 response: ResponseSummary {
1940 status_details: Some(ResponseStatusDetails {
1941 reason: Some("max_output_tokens".into()),
1942 r#type: Some("incomplete".into()),
1943 error: None,
1944 }),
1945 output: vec![response_item_function_call(
1946 "item_fn",
1947 Some("{\"city\":\"Boston\"}"),
1948 )],
1949 ..Default::default()
1950 },
1951 },
1952 ];
1953
1954 let mapped = map_response_events(events);
1955 assert_eq!(mapped.len(), 3);
1956 // First event is the partial tool use (from FunctionCallArgumentsDelta)
1957 assert!(matches!(
1958 mapped[0],
1959 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1960 is_input_complete: false,
1961 ..
1962 })
1963 ));
1964 // Second event is the complete tool use (from the Incomplete response output)
1965 assert!(matches!(
1966 mapped[1],
1967 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1968 ref raw_input,
1969 is_input_complete: true,
1970 ..
1971 })
1972 if raw_input == "{\"city\":\"Boston\"}"
1973 ));
1974 assert!(matches!(
1975 mapped[2],
1976 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1977 ));
1978 }
1979
1980 #[test]
1981 fn responses_stream_incomplete_does_not_duplicate_tool_calls() {
1982 let events = vec![
1983 ResponsesStreamEvent::OutputItemAdded {
1984 output_index: 0,
1985 sequence_number: None,
1986 item: response_item_function_call("item_fn", Some("{\"city\":\"Boston\"}")),
1987 },
1988 ResponsesStreamEvent::FunctionCallArgumentsDone {
1989 item_id: "item_fn".into(),
1990 output_index: 0,
1991 arguments: "{\"city\":\"Boston\"}".into(),
1992 sequence_number: None,
1993 },
1994 ResponsesStreamEvent::Incomplete {
1995 response: ResponseSummary {
1996 status_details: Some(ResponseStatusDetails {
1997 reason: Some("max_output_tokens".into()),
1998 r#type: Some("incomplete".into()),
1999 error: None,
2000 }),
2001 output: vec![response_item_function_call(
2002 "item_fn",
2003 Some("{\"city\":\"Boston\"}"),
2004 )],
2005 ..Default::default()
2006 },
2007 },
2008 ];
2009
2010 let mapped = map_response_events(events);
2011 assert_eq!(mapped.len(), 2);
2012 assert!(matches!(
2013 mapped[0],
2014 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
2015 if raw_input == "{\"city\":\"Boston\"}"
2016 ));
2017 assert!(matches!(
2018 mapped[1],
2019 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
2020 ));
2021 }
2022
2023 #[test]
2024 fn responses_stream_handles_empty_tool_arguments() {
2025 // Test that tools with no arguments (empty string) are handled correctly
2026 let events = vec![
2027 ResponsesStreamEvent::OutputItemAdded {
2028 output_index: 0,
2029 sequence_number: None,
2030 item: response_item_function_call("item_fn", Some("")),
2031 },
2032 ResponsesStreamEvent::FunctionCallArgumentsDone {
2033 item_id: "item_fn".into(),
2034 output_index: 0,
2035 arguments: "".into(),
2036 sequence_number: None,
2037 },
2038 ResponsesStreamEvent::Completed {
2039 response: ResponseSummary::default(),
2040 },
2041 ];
2042
2043 let mapped = map_response_events(events);
2044 assert_eq!(mapped.len(), 2);
2045
2046 // Should produce a ToolUse event with an empty object
2047 assert!(matches!(
2048 &mapped[0],
2049 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2050 id,
2051 name,
2052 raw_input,
2053 input,
2054 ..
2055 }) if id.to_string() == "call_123"
2056 && name.as_ref() == "get_weather"
2057 && raw_input == ""
2058 && input.is_object()
2059 && input.as_object().unwrap().is_empty()
2060 ));
2061
2062 assert!(matches!(
2063 mapped[1],
2064 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
2065 ));
2066 }
2067
2068 #[test]
2069 fn responses_stream_emits_partial_tool_use_events() {
2070 let events = vec![
2071 ResponsesStreamEvent::OutputItemAdded {
2072 output_index: 0,
2073 sequence_number: None,
2074 item: ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
2075 id: Some("item_fn".to_string()),
2076 status: Some("in_progress".to_string()),
2077 name: Some("get_weather".to_string()),
2078 call_id: Some("call_abc".to_string()),
2079 arguments: String::new(),
2080 }),
2081 },
2082 ResponsesStreamEvent::FunctionCallArgumentsDelta {
2083 item_id: "item_fn".into(),
2084 output_index: 0,
2085 delta: "{\"city\":\"Bos".into(),
2086 sequence_number: None,
2087 },
2088 ResponsesStreamEvent::FunctionCallArgumentsDelta {
2089 item_id: "item_fn".into(),
2090 output_index: 0,
2091 delta: "ton\"}".into(),
2092 sequence_number: None,
2093 },
2094 ResponsesStreamEvent::FunctionCallArgumentsDone {
2095 item_id: "item_fn".into(),
2096 output_index: 0,
2097 arguments: "{\"city\":\"Boston\"}".into(),
2098 sequence_number: None,
2099 },
2100 ResponsesStreamEvent::Completed {
2101 response: ResponseSummary::default(),
2102 },
2103 ];
2104
2105 let mapped = map_response_events(events);
2106 // Two partial events + one complete event + Stop
2107 assert!(mapped.len() >= 3);
2108
2109 // The last complete ToolUse event should have is_input_complete: true
2110 let complete_tool_use = mapped.iter().find(|e| {
2111 matches!(
2112 e,
2113 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2114 is_input_complete: true,
2115 ..
2116 })
2117 )
2118 });
2119 assert!(
2120 complete_tool_use.is_some(),
2121 "should have a complete tool use event"
2122 );
2123
2124 // All ToolUse events before the final one should have is_input_complete: false
2125 let tool_uses: Vec<_> = mapped
2126 .iter()
2127 .filter(|e| matches!(e, LanguageModelCompletionEvent::ToolUse(_)))
2128 .collect();
2129 assert!(
2130 tool_uses.len() >= 2,
2131 "should have at least one partial and one complete event"
2132 );
2133
2134 let last = tool_uses.last().unwrap();
2135 assert!(matches!(
2136 last,
2137 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
2138 is_input_complete: true,
2139 ..
2140 })
2141 ));
2142 }
2143
2144 #[test]
2145 fn responses_stream_maps_reasoning_summary_deltas() {
2146 let events = vec![
2147 ResponsesStreamEvent::OutputItemAdded {
2148 output_index: 0,
2149 sequence_number: None,
2150 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2151 id: Some("rs_123".into()),
2152 summary: vec![],
2153 }),
2154 },
2155 ResponsesStreamEvent::ReasoningSummaryPartAdded {
2156 item_id: "rs_123".into(),
2157 output_index: 0,
2158 summary_index: 0,
2159 },
2160 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2161 item_id: "rs_123".into(),
2162 output_index: 0,
2163 delta: "Thinking about".into(),
2164 },
2165 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2166 item_id: "rs_123".into(),
2167 output_index: 0,
2168 delta: " the answer".into(),
2169 },
2170 ResponsesStreamEvent::ReasoningSummaryTextDone {
2171 item_id: "rs_123".into(),
2172 output_index: 0,
2173 text: "Thinking about the answer".into(),
2174 },
2175 ResponsesStreamEvent::ReasoningSummaryPartDone {
2176 item_id: "rs_123".into(),
2177 output_index: 0,
2178 summary_index: 0,
2179 },
2180 ResponsesStreamEvent::ReasoningSummaryPartAdded {
2181 item_id: "rs_123".into(),
2182 output_index: 0,
2183 summary_index: 1,
2184 },
2185 ResponsesStreamEvent::ReasoningSummaryTextDelta {
2186 item_id: "rs_123".into(),
2187 output_index: 0,
2188 delta: "Second part".into(),
2189 },
2190 ResponsesStreamEvent::ReasoningSummaryTextDone {
2191 item_id: "rs_123".into(),
2192 output_index: 0,
2193 text: "Second part".into(),
2194 },
2195 ResponsesStreamEvent::ReasoningSummaryPartDone {
2196 item_id: "rs_123".into(),
2197 output_index: 0,
2198 summary_index: 1,
2199 },
2200 ResponsesStreamEvent::OutputItemDone {
2201 output_index: 0,
2202 sequence_number: None,
2203 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2204 id: Some("rs_123".into()),
2205 summary: vec![
2206 ReasoningSummaryPart::SummaryText {
2207 text: "Thinking about the answer".into(),
2208 },
2209 ReasoningSummaryPart::SummaryText {
2210 text: "Second part".into(),
2211 },
2212 ],
2213 }),
2214 },
2215 ResponsesStreamEvent::OutputItemAdded {
2216 output_index: 1,
2217 sequence_number: None,
2218 item: response_item_message("msg_456"),
2219 },
2220 ResponsesStreamEvent::OutputTextDelta {
2221 item_id: "msg_456".into(),
2222 output_index: 1,
2223 content_index: Some(0),
2224 delta: "The answer is 42".into(),
2225 },
2226 ResponsesStreamEvent::Completed {
2227 response: ResponseSummary::default(),
2228 },
2229 ];
2230
2231 let mapped = map_response_events(events);
2232
2233 let thinking_events: Vec<_> = mapped
2234 .iter()
2235 .filter(|e| matches!(e, LanguageModelCompletionEvent::Thinking { .. }))
2236 .collect();
2237 assert_eq!(
2238 thinking_events.len(),
2239 4,
2240 "expected 4 thinking events (2 deltas + separator + second delta), got {:?}",
2241 thinking_events,
2242 );
2243
2244 assert!(matches!(
2245 &thinking_events[0],
2246 LanguageModelCompletionEvent::Thinking { text, .. } if text == "Thinking about"
2247 ));
2248 assert!(matches!(
2249 &thinking_events[1],
2250 LanguageModelCompletionEvent::Thinking { text, .. } if text == " the answer"
2251 ));
2252 assert!(
2253 matches!(
2254 &thinking_events[2],
2255 LanguageModelCompletionEvent::Thinking { text, .. } if text == "\n\n"
2256 ),
2257 "expected separator between summary parts"
2258 );
2259 assert!(matches!(
2260 &thinking_events[3],
2261 LanguageModelCompletionEvent::Thinking { text, .. } if text == "Second part"
2262 ));
2263
2264 assert!(mapped.iter().any(|e| matches!(
2265 e,
2266 LanguageModelCompletionEvent::Text(t) if t == "The answer is 42"
2267 )));
2268 }
2269
2270 #[test]
2271 fn responses_stream_maps_reasoning_from_done_only() {
2272 let events = vec![
2273 ResponsesStreamEvent::OutputItemAdded {
2274 output_index: 0,
2275 sequence_number: None,
2276 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2277 id: Some("rs_789".into()),
2278 summary: vec![],
2279 }),
2280 },
2281 ResponsesStreamEvent::OutputItemDone {
2282 output_index: 0,
2283 sequence_number: None,
2284 item: ResponseOutputItem::Reasoning(ResponseReasoningItem {
2285 id: Some("rs_789".into()),
2286 summary: vec![ReasoningSummaryPart::SummaryText {
2287 text: "Summary without deltas".into(),
2288 }],
2289 }),
2290 },
2291 ResponsesStreamEvent::Completed {
2292 response: ResponseSummary::default(),
2293 },
2294 ];
2295
2296 let mapped = map_response_events(events);
2297
2298 assert!(
2299 !mapped
2300 .iter()
2301 .any(|e| matches!(e, LanguageModelCompletionEvent::Thinking { .. })),
2302 "OutputItemDone reasoning should not produce Thinking events (no delta/done text events)"
2303 );
2304 }
2305}