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_thinking(&self) -> bool {
334 self.model.reasoning_effort().is_some()
335 }
336
337 fn supports_split_token_display(&self) -> bool {
338 true
339 }
340
341 fn telemetry_id(&self) -> String {
342 format!("openai/{}", self.model.id())
343 }
344
345 fn max_token_count(&self) -> u64 {
346 self.model.max_token_count()
347 }
348
349 fn max_output_tokens(&self) -> Option<u64> {
350 self.model.max_output_tokens()
351 }
352
353 fn count_tokens(
354 &self,
355 request: LanguageModelRequest,
356 cx: &App,
357 ) -> BoxFuture<'static, Result<u64>> {
358 count_open_ai_tokens(request, self.model.clone(), cx)
359 }
360
361 fn stream_completion(
362 &self,
363 request: LanguageModelRequest,
364 cx: &AsyncApp,
365 ) -> BoxFuture<
366 'static,
367 Result<
368 futures::stream::BoxStream<
369 'static,
370 Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
371 >,
372 LanguageModelCompletionError,
373 >,
374 > {
375 if self.model.supports_chat_completions() {
376 let request = into_open_ai(
377 request,
378 self.model.id(),
379 self.model.supports_parallel_tool_calls(),
380 self.model.supports_prompt_cache_key(),
381 self.max_output_tokens(),
382 self.model.reasoning_effort(),
383 );
384 let completions = self.stream_completion(request, cx);
385 async move {
386 let mapper = OpenAiEventMapper::new();
387 Ok(mapper.map_stream(completions.await?).boxed())
388 }
389 .boxed()
390 } else {
391 let request = into_open_ai_response(
392 request,
393 self.model.id(),
394 self.model.supports_parallel_tool_calls(),
395 self.model.supports_prompt_cache_key(),
396 self.max_output_tokens(),
397 self.model.reasoning_effort(),
398 );
399 let completions = self.stream_response(request, cx);
400 async move {
401 let mapper = OpenAiResponseEventMapper::new();
402 Ok(mapper.map_stream(completions.await?).boxed())
403 }
404 .boxed()
405 }
406 }
407}
408
409pub fn into_open_ai(
410 request: LanguageModelRequest,
411 model_id: &str,
412 supports_parallel_tool_calls: bool,
413 supports_prompt_cache_key: bool,
414 max_output_tokens: Option<u64>,
415 reasoning_effort: Option<ReasoningEffort>,
416) -> open_ai::Request {
417 let stream = !model_id.starts_with("o1-");
418
419 let mut messages = Vec::new();
420 for message in request.messages {
421 for content in message.content {
422 match content {
423 MessageContent::Text(text) | MessageContent::Thinking { text, .. } => {
424 let should_add = if message.role == Role::User {
425 // Including whitespace-only user messages can cause error with OpenAI compatible APIs
426 // See https://github.com/zed-industries/zed/issues/40097
427 !text.trim().is_empty()
428 } else {
429 !text.is_empty()
430 };
431 if should_add {
432 add_message_content_part(
433 open_ai::MessagePart::Text { text },
434 message.role,
435 &mut messages,
436 );
437 }
438 }
439 MessageContent::RedactedThinking(_) => {}
440 MessageContent::Image(image) => {
441 add_message_content_part(
442 open_ai::MessagePart::Image {
443 image_url: ImageUrl {
444 url: image.to_base64_url(),
445 detail: None,
446 },
447 },
448 message.role,
449 &mut messages,
450 );
451 }
452 MessageContent::ToolUse(tool_use) => {
453 let tool_call = open_ai::ToolCall {
454 id: tool_use.id.to_string(),
455 content: open_ai::ToolCallContent::Function {
456 function: open_ai::FunctionContent {
457 name: tool_use.name.to_string(),
458 arguments: serde_json::to_string(&tool_use.input)
459 .unwrap_or_default(),
460 },
461 },
462 };
463
464 if let Some(open_ai::RequestMessage::Assistant { tool_calls, .. }) =
465 messages.last_mut()
466 {
467 tool_calls.push(tool_call);
468 } else {
469 messages.push(open_ai::RequestMessage::Assistant {
470 content: None,
471 tool_calls: vec![tool_call],
472 });
473 }
474 }
475 MessageContent::ToolResult(tool_result) => {
476 let content = match &tool_result.content {
477 LanguageModelToolResultContent::Text(text) => {
478 vec![open_ai::MessagePart::Text {
479 text: text.to_string(),
480 }]
481 }
482 LanguageModelToolResultContent::Image(image) => {
483 vec![open_ai::MessagePart::Image {
484 image_url: ImageUrl {
485 url: image.to_base64_url(),
486 detail: None,
487 },
488 }]
489 }
490 };
491
492 messages.push(open_ai::RequestMessage::Tool {
493 content: content.into(),
494 tool_call_id: tool_result.tool_use_id.to_string(),
495 });
496 }
497 }
498 }
499 }
500
501 open_ai::Request {
502 model: model_id.into(),
503 messages,
504 stream,
505 stop: request.stop,
506 temperature: request.temperature.or(Some(1.0)),
507 max_completion_tokens: max_output_tokens,
508 parallel_tool_calls: if supports_parallel_tool_calls && !request.tools.is_empty() {
509 // Disable parallel tool calls, as the Agent currently expects a maximum of one per turn.
510 Some(false)
511 } else {
512 None
513 },
514 prompt_cache_key: if supports_prompt_cache_key {
515 request.thread_id
516 } else {
517 None
518 },
519 tools: request
520 .tools
521 .into_iter()
522 .map(|tool| open_ai::ToolDefinition::Function {
523 function: open_ai::FunctionDefinition {
524 name: tool.name,
525 description: Some(tool.description),
526 parameters: Some(tool.input_schema),
527 },
528 })
529 .collect(),
530 tool_choice: request.tool_choice.map(|choice| match choice {
531 LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
532 LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
533 LanguageModelToolChoice::None => open_ai::ToolChoice::None,
534 }),
535 reasoning_effort,
536 }
537}
538
539pub fn into_open_ai_response(
540 request: LanguageModelRequest,
541 model_id: &str,
542 supports_parallel_tool_calls: bool,
543 supports_prompt_cache_key: bool,
544 max_output_tokens: Option<u64>,
545 reasoning_effort: Option<ReasoningEffort>,
546) -> ResponseRequest {
547 let stream = !model_id.starts_with("o1-");
548
549 let LanguageModelRequest {
550 thread_id,
551 prompt_id: _,
552 intent: _,
553 messages,
554 tools,
555 tool_choice,
556 stop: _,
557 temperature,
558 thinking_allowed: _,
559 thinking_effort: _,
560 speed: _,
561 } = request;
562
563 let mut input_items = Vec::new();
564 for (index, message) in messages.into_iter().enumerate() {
565 append_message_to_response_items(message, index, &mut input_items);
566 }
567
568 let tools: Vec<_> = tools
569 .into_iter()
570 .map(|tool| open_ai::responses::ToolDefinition::Function {
571 name: tool.name,
572 description: Some(tool.description),
573 parameters: Some(tool.input_schema),
574 strict: None,
575 })
576 .collect();
577
578 ResponseRequest {
579 model: model_id.into(),
580 input: input_items,
581 stream,
582 temperature,
583 top_p: None,
584 max_output_tokens,
585 parallel_tool_calls: if tools.is_empty() {
586 None
587 } else {
588 Some(supports_parallel_tool_calls)
589 },
590 tool_choice: tool_choice.map(|choice| match choice {
591 LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto,
592 LanguageModelToolChoice::Any => open_ai::ToolChoice::Required,
593 LanguageModelToolChoice::None => open_ai::ToolChoice::None,
594 }),
595 tools,
596 prompt_cache_key: if supports_prompt_cache_key {
597 thread_id
598 } else {
599 None
600 },
601 reasoning: reasoning_effort.map(|effort| open_ai::responses::ReasoningConfig { effort }),
602 }
603}
604
605fn append_message_to_response_items(
606 message: LanguageModelRequestMessage,
607 index: usize,
608 input_items: &mut Vec<ResponseInputItem>,
609) {
610 let mut content_parts: Vec<ResponseInputContent> = Vec::new();
611
612 for content in message.content {
613 match content {
614 MessageContent::Text(text) => {
615 push_response_text_part(&message.role, text, &mut content_parts);
616 }
617 MessageContent::Thinking { text, .. } => {
618 push_response_text_part(&message.role, text, &mut content_parts);
619 }
620 MessageContent::RedactedThinking(_) => {}
621 MessageContent::Image(image) => {
622 push_response_image_part(&message.role, image, &mut content_parts);
623 }
624 MessageContent::ToolUse(tool_use) => {
625 flush_response_parts(&message.role, index, &mut content_parts, input_items);
626 let call_id = tool_use.id.to_string();
627 input_items.push(ResponseInputItem::FunctionCall(ResponseFunctionCallItem {
628 call_id,
629 name: tool_use.name.to_string(),
630 arguments: tool_use.raw_input,
631 }));
632 }
633 MessageContent::ToolResult(tool_result) => {
634 flush_response_parts(&message.role, index, &mut content_parts, input_items);
635 input_items.push(ResponseInputItem::FunctionCallOutput(
636 ResponseFunctionCallOutputItem {
637 call_id: tool_result.tool_use_id.to_string(),
638 output: tool_result_output(&tool_result),
639 },
640 ));
641 }
642 }
643 }
644
645 flush_response_parts(&message.role, index, &mut content_parts, input_items);
646}
647
648fn push_response_text_part(
649 role: &Role,
650 text: impl Into<String>,
651 parts: &mut Vec<ResponseInputContent>,
652) {
653 let text = text.into();
654 if text.trim().is_empty() {
655 return;
656 }
657
658 match role {
659 Role::Assistant => parts.push(ResponseInputContent::OutputText {
660 text,
661 annotations: Vec::new(),
662 }),
663 _ => parts.push(ResponseInputContent::Text { text }),
664 }
665}
666
667fn push_response_image_part(
668 role: &Role,
669 image: LanguageModelImage,
670 parts: &mut Vec<ResponseInputContent>,
671) {
672 match role {
673 Role::Assistant => parts.push(ResponseInputContent::OutputText {
674 text: "[image omitted]".to_string(),
675 annotations: Vec::new(),
676 }),
677 _ => parts.push(ResponseInputContent::Image {
678 image_url: image.to_base64_url(),
679 }),
680 }
681}
682
683fn flush_response_parts(
684 role: &Role,
685 _index: usize,
686 parts: &mut Vec<ResponseInputContent>,
687 input_items: &mut Vec<ResponseInputItem>,
688) {
689 if parts.is_empty() {
690 return;
691 }
692
693 let item = ResponseInputItem::Message(ResponseMessageItem {
694 role: match role {
695 Role::User => open_ai::Role::User,
696 Role::Assistant => open_ai::Role::Assistant,
697 Role::System => open_ai::Role::System,
698 },
699 content: parts.clone(),
700 });
701
702 input_items.push(item);
703 parts.clear();
704}
705
706fn tool_result_output(result: &LanguageModelToolResult) -> String {
707 if let Some(output) = &result.output {
708 match output {
709 serde_json::Value::String(text) => text.clone(),
710 serde_json::Value::Null => String::new(),
711 _ => output.to_string(),
712 }
713 } else {
714 match &result.content {
715 LanguageModelToolResultContent::Text(text) => text.to_string(),
716 LanguageModelToolResultContent::Image(image) => image.to_base64_url(),
717 }
718 }
719}
720
721fn add_message_content_part(
722 new_part: open_ai::MessagePart,
723 role: Role,
724 messages: &mut Vec<open_ai::RequestMessage>,
725) {
726 match (role, messages.last_mut()) {
727 (Role::User, Some(open_ai::RequestMessage::User { content }))
728 | (
729 Role::Assistant,
730 Some(open_ai::RequestMessage::Assistant {
731 content: Some(content),
732 ..
733 }),
734 )
735 | (Role::System, Some(open_ai::RequestMessage::System { content, .. })) => {
736 content.push_part(new_part);
737 }
738 _ => {
739 messages.push(match role {
740 Role::User => open_ai::RequestMessage::User {
741 content: open_ai::MessageContent::from(vec![new_part]),
742 },
743 Role::Assistant => open_ai::RequestMessage::Assistant {
744 content: Some(open_ai::MessageContent::from(vec![new_part])),
745 tool_calls: Vec::new(),
746 },
747 Role::System => open_ai::RequestMessage::System {
748 content: open_ai::MessageContent::from(vec![new_part]),
749 },
750 });
751 }
752 }
753}
754
755pub struct OpenAiEventMapper {
756 tool_calls_by_index: HashMap<usize, RawToolCall>,
757}
758
759impl OpenAiEventMapper {
760 pub fn new() -> Self {
761 Self {
762 tool_calls_by_index: HashMap::default(),
763 }
764 }
765
766 pub fn map_stream(
767 mut self,
768 events: Pin<Box<dyn Send + Stream<Item = Result<ResponseStreamEvent>>>>,
769 ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
770 {
771 events.flat_map(move |event| {
772 futures::stream::iter(match event {
773 Ok(event) => self.map_event(event),
774 Err(error) => vec![Err(LanguageModelCompletionError::from(anyhow!(error)))],
775 })
776 })
777 }
778
779 pub fn map_event(
780 &mut self,
781 event: ResponseStreamEvent,
782 ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
783 let mut events = Vec::new();
784 if let Some(usage) = event.usage {
785 events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
786 input_tokens: usage.prompt_tokens,
787 output_tokens: usage.completion_tokens,
788 cache_creation_input_tokens: 0,
789 cache_read_input_tokens: 0,
790 })));
791 }
792
793 let Some(choice) = event.choices.first() else {
794 return events;
795 };
796
797 if let Some(delta) = choice.delta.as_ref() {
798 if let Some(reasoning_content) = delta.reasoning_content.clone() {
799 if !reasoning_content.is_empty() {
800 events.push(Ok(LanguageModelCompletionEvent::Thinking {
801 text: reasoning_content,
802 signature: None,
803 }));
804 }
805 }
806 if let Some(content) = delta.content.clone() {
807 if !content.is_empty() {
808 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
809 }
810 }
811
812 if let Some(tool_calls) = delta.tool_calls.as_ref() {
813 for tool_call in tool_calls {
814 let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();
815
816 if let Some(tool_id) = tool_call.id.clone() {
817 entry.id = tool_id;
818 }
819
820 if let Some(function) = tool_call.function.as_ref() {
821 if let Some(name) = function.name.clone() {
822 entry.name = name;
823 }
824
825 if let Some(arguments) = function.arguments.clone() {
826 entry.arguments.push_str(&arguments);
827 }
828 }
829 }
830 }
831 }
832
833 match choice.finish_reason.as_deref() {
834 Some("stop") => {
835 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
836 }
837 Some("tool_calls") => {
838 events.extend(self.tool_calls_by_index.drain().map(|(_, tool_call)| {
839 match parse_tool_arguments(&tool_call.arguments) {
840 Ok(input) => Ok(LanguageModelCompletionEvent::ToolUse(
841 LanguageModelToolUse {
842 id: tool_call.id.clone().into(),
843 name: tool_call.name.as_str().into(),
844 is_input_complete: true,
845 input,
846 raw_input: tool_call.arguments.clone(),
847 thought_signature: None,
848 },
849 )),
850 Err(error) => Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
851 id: tool_call.id.into(),
852 tool_name: tool_call.name.into(),
853 raw_input: tool_call.arguments.clone().into(),
854 json_parse_error: error.to_string(),
855 }),
856 }
857 }));
858
859 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));
860 }
861 Some(stop_reason) => {
862 log::error!("Unexpected OpenAI stop_reason: {stop_reason:?}",);
863 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
864 }
865 None => {}
866 }
867
868 events
869 }
870}
871
872#[derive(Default)]
873struct RawToolCall {
874 id: String,
875 name: String,
876 arguments: String,
877}
878
879pub struct OpenAiResponseEventMapper {
880 function_calls_by_item: HashMap<String, PendingResponseFunctionCall>,
881 pending_stop_reason: Option<StopReason>,
882}
883
884#[derive(Default)]
885struct PendingResponseFunctionCall {
886 call_id: String,
887 name: Arc<str>,
888 arguments: String,
889}
890
891impl OpenAiResponseEventMapper {
892 pub fn new() -> Self {
893 Self {
894 function_calls_by_item: HashMap::default(),
895 pending_stop_reason: None,
896 }
897 }
898
899 pub fn map_stream(
900 mut self,
901 events: Pin<Box<dyn Send + Stream<Item = Result<ResponsesStreamEvent>>>>,
902 ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
903 {
904 events.flat_map(move |event| {
905 futures::stream::iter(match event {
906 Ok(event) => self.map_event(event),
907 Err(error) => vec![Err(LanguageModelCompletionError::from(anyhow!(error)))],
908 })
909 })
910 }
911
912 pub fn map_event(
913 &mut self,
914 event: ResponsesStreamEvent,
915 ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
916 match event {
917 ResponsesStreamEvent::OutputItemAdded { item, .. } => {
918 let mut events = Vec::new();
919
920 match &item {
921 ResponseOutputItem::Message(message) => {
922 if let Some(id) = &message.id {
923 events.push(Ok(LanguageModelCompletionEvent::StartMessage {
924 message_id: id.clone(),
925 }));
926 }
927 }
928 ResponseOutputItem::FunctionCall(function_call) => {
929 if let Some(item_id) = function_call.id.clone() {
930 let call_id = function_call
931 .call_id
932 .clone()
933 .or_else(|| function_call.id.clone())
934 .unwrap_or_else(|| item_id.clone());
935 let entry = PendingResponseFunctionCall {
936 call_id,
937 name: Arc::<str>::from(
938 function_call.name.clone().unwrap_or_default(),
939 ),
940 arguments: function_call.arguments.clone(),
941 };
942 self.function_calls_by_item.insert(item_id, entry);
943 }
944 }
945 ResponseOutputItem::Unknown => {}
946 }
947 events
948 }
949 ResponsesStreamEvent::OutputTextDelta { delta, .. } => {
950 if delta.is_empty() {
951 Vec::new()
952 } else {
953 vec![Ok(LanguageModelCompletionEvent::Text(delta))]
954 }
955 }
956 ResponsesStreamEvent::FunctionCallArgumentsDelta { item_id, delta, .. } => {
957 if let Some(entry) = self.function_calls_by_item.get_mut(&item_id) {
958 entry.arguments.push_str(&delta);
959 }
960 Vec::new()
961 }
962 ResponsesStreamEvent::FunctionCallArgumentsDone {
963 item_id, arguments, ..
964 } => {
965 if let Some(mut entry) = self.function_calls_by_item.remove(&item_id) {
966 if !arguments.is_empty() {
967 entry.arguments = arguments;
968 }
969 let raw_input = entry.arguments.clone();
970 self.pending_stop_reason = Some(StopReason::ToolUse);
971 match parse_tool_arguments(&entry.arguments) {
972 Ok(input) => {
973 vec![Ok(LanguageModelCompletionEvent::ToolUse(
974 LanguageModelToolUse {
975 id: LanguageModelToolUseId::from(entry.call_id.clone()),
976 name: entry.name.clone(),
977 is_input_complete: true,
978 input,
979 raw_input,
980 thought_signature: None,
981 },
982 ))]
983 }
984 Err(error) => {
985 vec![Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
986 id: LanguageModelToolUseId::from(entry.call_id.clone()),
987 tool_name: entry.name.clone(),
988 raw_input: Arc::<str>::from(raw_input),
989 json_parse_error: error.to_string(),
990 })]
991 }
992 }
993 } else {
994 Vec::new()
995 }
996 }
997 ResponsesStreamEvent::Completed { response } => {
998 self.handle_completion(response, StopReason::EndTurn)
999 }
1000 ResponsesStreamEvent::Incomplete { response } => {
1001 let reason = response
1002 .status_details
1003 .as_ref()
1004 .and_then(|details| details.reason.as_deref());
1005 let stop_reason = match reason {
1006 Some("max_output_tokens") => StopReason::MaxTokens,
1007 Some("content_filter") => {
1008 self.pending_stop_reason = Some(StopReason::Refusal);
1009 StopReason::Refusal
1010 }
1011 _ => self
1012 .pending_stop_reason
1013 .take()
1014 .unwrap_or(StopReason::EndTurn),
1015 };
1016
1017 let mut events = Vec::new();
1018 if self.pending_stop_reason.is_none() {
1019 events.extend(self.emit_tool_calls_from_output(&response.output));
1020 }
1021 if let Some(usage) = response.usage.as_ref() {
1022 events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(
1023 token_usage_from_response_usage(usage),
1024 )));
1025 }
1026 events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));
1027 events
1028 }
1029 ResponsesStreamEvent::Failed { response } => {
1030 let message = response
1031 .status_details
1032 .and_then(|details| details.error)
1033 .map(|error| error.to_string())
1034 .unwrap_or_else(|| "response failed".to_string());
1035 vec![Err(LanguageModelCompletionError::Other(anyhow!(message)))]
1036 }
1037 ResponsesStreamEvent::Error { error }
1038 | ResponsesStreamEvent::GenericError { error } => {
1039 vec![Err(LanguageModelCompletionError::Other(anyhow!(format!(
1040 "{error:?}"
1041 ))))]
1042 }
1043 ResponsesStreamEvent::OutputTextDone { .. } => Vec::new(),
1044 ResponsesStreamEvent::OutputItemDone { .. }
1045 | ResponsesStreamEvent::ContentPartAdded { .. }
1046 | ResponsesStreamEvent::ContentPartDone { .. }
1047 | ResponsesStreamEvent::Created { .. }
1048 | ResponsesStreamEvent::InProgress { .. }
1049 | ResponsesStreamEvent::Unknown => Vec::new(),
1050 }
1051 }
1052
1053 fn handle_completion(
1054 &mut self,
1055 response: ResponsesSummary,
1056 default_reason: StopReason,
1057 ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
1058 let mut events = Vec::new();
1059
1060 if self.pending_stop_reason.is_none() {
1061 events.extend(self.emit_tool_calls_from_output(&response.output));
1062 }
1063
1064 if let Some(usage) = response.usage.as_ref() {
1065 events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(
1066 token_usage_from_response_usage(usage),
1067 )));
1068 }
1069
1070 let stop_reason = self.pending_stop_reason.take().unwrap_or(default_reason);
1071 events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));
1072 events
1073 }
1074
1075 fn emit_tool_calls_from_output(
1076 &mut self,
1077 output: &[ResponseOutputItem],
1078 ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
1079 let mut events = Vec::new();
1080 for item in output {
1081 if let ResponseOutputItem::FunctionCall(function_call) = item {
1082 let Some(call_id) = function_call
1083 .call_id
1084 .clone()
1085 .or_else(|| function_call.id.clone())
1086 else {
1087 log::error!(
1088 "Function call item missing both call_id and id: {:?}",
1089 function_call
1090 );
1091 continue;
1092 };
1093 let name: Arc<str> = Arc::from(function_call.name.clone().unwrap_or_default());
1094 let arguments = &function_call.arguments;
1095 self.pending_stop_reason = Some(StopReason::ToolUse);
1096 match parse_tool_arguments(arguments) {
1097 Ok(input) => {
1098 events.push(Ok(LanguageModelCompletionEvent::ToolUse(
1099 LanguageModelToolUse {
1100 id: LanguageModelToolUseId::from(call_id.clone()),
1101 name: name.clone(),
1102 is_input_complete: true,
1103 input,
1104 raw_input: arguments.clone(),
1105 thought_signature: None,
1106 },
1107 )));
1108 }
1109 Err(error) => {
1110 events.push(Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
1111 id: LanguageModelToolUseId::from(call_id.clone()),
1112 tool_name: name.clone(),
1113 raw_input: Arc::<str>::from(arguments.clone()),
1114 json_parse_error: error.to_string(),
1115 }));
1116 }
1117 }
1118 }
1119 }
1120 events
1121 }
1122}
1123
1124fn token_usage_from_response_usage(usage: &ResponsesUsage) -> TokenUsage {
1125 TokenUsage {
1126 input_tokens: usage.input_tokens.unwrap_or_default(),
1127 output_tokens: usage.output_tokens.unwrap_or_default(),
1128 cache_creation_input_tokens: 0,
1129 cache_read_input_tokens: 0,
1130 }
1131}
1132
1133pub(crate) fn collect_tiktoken_messages(
1134 request: LanguageModelRequest,
1135) -> Vec<tiktoken_rs::ChatCompletionRequestMessage> {
1136 request
1137 .messages
1138 .into_iter()
1139 .map(|message| tiktoken_rs::ChatCompletionRequestMessage {
1140 role: match message.role {
1141 Role::User => "user".into(),
1142 Role::Assistant => "assistant".into(),
1143 Role::System => "system".into(),
1144 },
1145 content: Some(message.string_contents()),
1146 name: None,
1147 function_call: None,
1148 })
1149 .collect::<Vec<_>>()
1150}
1151
1152pub fn count_open_ai_tokens(
1153 request: LanguageModelRequest,
1154 model: Model,
1155 cx: &App,
1156) -> BoxFuture<'static, Result<u64>> {
1157 cx.background_spawn(async move {
1158 let messages = collect_tiktoken_messages(request);
1159 match model {
1160 Model::Custom { max_tokens, .. } => {
1161 let model = if max_tokens >= 100_000 {
1162 // If the max tokens is 100k or more, it likely uses the o200k_base tokenizer
1163 "gpt-4o"
1164 } else {
1165 // Otherwise fallback to gpt-4, since only cl100k_base and o200k_base are
1166 // supported with this tiktoken method
1167 "gpt-4"
1168 };
1169 tiktoken_rs::num_tokens_from_messages(model, &messages)
1170 }
1171 // Currently supported by tiktoken_rs
1172 // Sometimes tiktoken-rs is behind on model support. If that is the case, make a new branch
1173 // arm with an override. We enumerate all supported models here so that we can check if new
1174 // models are supported yet or not.
1175 Model::ThreePointFiveTurbo
1176 | Model::Four
1177 | Model::FourTurbo
1178 | Model::FourOmniMini
1179 | Model::FourPointOneNano
1180 | Model::O1
1181 | Model::O3
1182 | Model::O3Mini
1183 | Model::Five
1184 | Model::FiveCodex
1185 | Model::FiveMini
1186 | Model::FiveNano => tiktoken_rs::num_tokens_from_messages(model.id(), &messages),
1187 // 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
1188 Model::FivePointOne
1189 | Model::FivePointTwo
1190 | Model::FivePointTwoCodex
1191 | Model::FivePointThreeCodex
1192 | Model::FivePointFour
1193 | Model::FivePointFourPro => tiktoken_rs::num_tokens_from_messages("gpt-5", &messages),
1194 }
1195 .map(|tokens| tokens as u64)
1196 })
1197 .boxed()
1198}
1199
1200struct ConfigurationView {
1201 api_key_editor: Entity<InputField>,
1202 state: Entity<State>,
1203 load_credentials_task: Option<Task<()>>,
1204}
1205
1206impl ConfigurationView {
1207 fn new(state: Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
1208 let api_key_editor = cx.new(|cx| {
1209 InputField::new(
1210 window,
1211 cx,
1212 "sk-000000000000000000000000000000000000000000000000",
1213 )
1214 });
1215
1216 cx.observe(&state, |_, _, cx| {
1217 cx.notify();
1218 })
1219 .detach();
1220
1221 let load_credentials_task = Some(cx.spawn_in(window, {
1222 let state = state.clone();
1223 async move |this, cx| {
1224 if let Some(task) = Some(state.update(cx, |state, cx| state.authenticate(cx))) {
1225 // We don't log an error, because "not signed in" is also an error.
1226 let _ = task.await;
1227 }
1228 this.update(cx, |this, cx| {
1229 this.load_credentials_task = None;
1230 cx.notify();
1231 })
1232 .log_err();
1233 }
1234 }));
1235
1236 Self {
1237 api_key_editor,
1238 state,
1239 load_credentials_task,
1240 }
1241 }
1242
1243 fn save_api_key(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
1244 let api_key = self.api_key_editor.read(cx).text(cx).trim().to_string();
1245 if api_key.is_empty() {
1246 return;
1247 }
1248
1249 // url changes can cause the editor to be displayed again
1250 self.api_key_editor
1251 .update(cx, |editor, cx| editor.set_text("", window, cx));
1252
1253 let state = self.state.clone();
1254 cx.spawn_in(window, async move |_, cx| {
1255 state
1256 .update(cx, |state, cx| state.set_api_key(Some(api_key), cx))
1257 .await
1258 })
1259 .detach_and_log_err(cx);
1260 }
1261
1262 fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1263 self.api_key_editor
1264 .update(cx, |input, cx| input.set_text("", window, cx));
1265
1266 let state = self.state.clone();
1267 cx.spawn_in(window, async move |_, cx| {
1268 state
1269 .update(cx, |state, cx| state.set_api_key(None, cx))
1270 .await
1271 })
1272 .detach_and_log_err(cx);
1273 }
1274
1275 fn should_render_editor(&self, cx: &mut Context<Self>) -> bool {
1276 !self.state.read(cx).is_authenticated()
1277 }
1278}
1279
1280impl Render for ConfigurationView {
1281 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1282 let env_var_set = self.state.read(cx).api_key_state.is_from_env_var();
1283 let configured_card_label = if env_var_set {
1284 format!("API key set in {API_KEY_ENV_VAR_NAME} environment variable")
1285 } else {
1286 let api_url = OpenAiLanguageModelProvider::api_url(cx);
1287 if api_url == OPEN_AI_API_URL {
1288 "API key configured".to_string()
1289 } else {
1290 format!("API key configured for {}", api_url)
1291 }
1292 };
1293
1294 let api_key_section = if self.should_render_editor(cx) {
1295 v_flex()
1296 .on_action(cx.listener(Self::save_api_key))
1297 .child(Label::new("To use Zed's agent with OpenAI, you need to add an API key. Follow these steps:"))
1298 .child(
1299 List::new()
1300 .child(
1301 ListBulletItem::new("")
1302 .child(Label::new("Create one by visiting"))
1303 .child(ButtonLink::new("OpenAI's console", "https://platform.openai.com/api-keys"))
1304 )
1305 .child(
1306 ListBulletItem::new("Ensure your OpenAI account has credits")
1307 )
1308 .child(
1309 ListBulletItem::new("Paste your API key below and hit enter to start using the agent")
1310 ),
1311 )
1312 .child(self.api_key_editor.clone())
1313 .child(
1314 Label::new(format!(
1315 "You can also set the {API_KEY_ENV_VAR_NAME} environment variable and restart Zed."
1316 ))
1317 .size(LabelSize::Small)
1318 .color(Color::Muted),
1319 )
1320 .child(
1321 Label::new(
1322 "Note that having a subscription for another service like GitHub Copilot won't work.",
1323 )
1324 .size(LabelSize::Small).color(Color::Muted),
1325 )
1326 .into_any_element()
1327 } else {
1328 ConfiguredApiCard::new(configured_card_label)
1329 .disabled(env_var_set)
1330 .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx)))
1331 .when(env_var_set, |this| {
1332 this.tooltip_label(format!("To reset your API key, unset the {API_KEY_ENV_VAR_NAME} environment variable."))
1333 })
1334 .into_any_element()
1335 };
1336
1337 let compatible_api_section = h_flex()
1338 .mt_1p5()
1339 .gap_0p5()
1340 .flex_wrap()
1341 .when(self.should_render_editor(cx), |this| {
1342 this.pt_1p5()
1343 .border_t_1()
1344 .border_color(cx.theme().colors().border_variant)
1345 })
1346 .child(
1347 h_flex()
1348 .gap_2()
1349 .child(
1350 Icon::new(IconName::Info)
1351 .size(IconSize::XSmall)
1352 .color(Color::Muted),
1353 )
1354 .child(Label::new("Zed also supports OpenAI-compatible models.")),
1355 )
1356 .child(
1357 Button::new("docs", "Learn More")
1358 .icon(IconName::ArrowUpRight)
1359 .icon_size(IconSize::Small)
1360 .icon_color(Color::Muted)
1361 .on_click(move |_, _window, cx| {
1362 cx.open_url("https://zed.dev/docs/ai/llm-providers#openai-api-compatible")
1363 }),
1364 );
1365
1366 if self.load_credentials_task.is_some() {
1367 div().child(Label::new("Loading credentials…")).into_any()
1368 } else {
1369 v_flex()
1370 .size_full()
1371 .child(api_key_section)
1372 .child(compatible_api_section)
1373 .into_any()
1374 }
1375 }
1376}
1377
1378#[cfg(test)]
1379mod tests {
1380 use futures::{StreamExt, executor::block_on};
1381 use gpui::TestAppContext;
1382 use language_model::{LanguageModelRequestMessage, LanguageModelRequestTool};
1383 use open_ai::responses::{
1384 ResponseFunctionToolCall, ResponseOutputItem, ResponseOutputMessage, ResponseStatusDetails,
1385 ResponseSummary, ResponseUsage, StreamEvent as ResponsesStreamEvent,
1386 };
1387 use pretty_assertions::assert_eq;
1388 use serde_json::json;
1389
1390 use super::*;
1391
1392 fn map_response_events(events: Vec<ResponsesStreamEvent>) -> Vec<LanguageModelCompletionEvent> {
1393 block_on(async {
1394 OpenAiResponseEventMapper::new()
1395 .map_stream(Box::pin(futures::stream::iter(events.into_iter().map(Ok))))
1396 .collect::<Vec<_>>()
1397 .await
1398 .into_iter()
1399 .map(Result::unwrap)
1400 .collect()
1401 })
1402 }
1403
1404 fn response_item_message(id: &str) -> ResponseOutputItem {
1405 ResponseOutputItem::Message(ResponseOutputMessage {
1406 id: Some(id.to_string()),
1407 role: Some("assistant".to_string()),
1408 status: Some("in_progress".to_string()),
1409 content: vec![],
1410 })
1411 }
1412
1413 fn response_item_function_call(id: &str, args: Option<&str>) -> ResponseOutputItem {
1414 ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
1415 id: Some(id.to_string()),
1416 status: Some("in_progress".to_string()),
1417 name: Some("get_weather".to_string()),
1418 call_id: Some("call_123".to_string()),
1419 arguments: args.map(|s| s.to_string()).unwrap_or_default(),
1420 })
1421 }
1422
1423 #[gpui::test]
1424 fn tiktoken_rs_support(cx: &TestAppContext) {
1425 let request = LanguageModelRequest {
1426 thread_id: None,
1427 prompt_id: None,
1428 intent: None,
1429 messages: vec![LanguageModelRequestMessage {
1430 role: Role::User,
1431 content: vec![MessageContent::Text("message".into())],
1432 cache: false,
1433 reasoning_details: None,
1434 }],
1435 tools: vec![],
1436 tool_choice: None,
1437 stop: vec![],
1438 temperature: None,
1439 thinking_allowed: true,
1440 thinking_effort: None,
1441 speed: None,
1442 };
1443
1444 // Validate that all models are supported by tiktoken-rs
1445 for model in Model::iter() {
1446 let count = cx
1447 .foreground_executor()
1448 .block_on(count_open_ai_tokens(
1449 request.clone(),
1450 model,
1451 &cx.app.borrow(),
1452 ))
1453 .unwrap();
1454 assert!(count > 0);
1455 }
1456 }
1457
1458 #[test]
1459 fn responses_stream_maps_text_and_usage() {
1460 let events = vec![
1461 ResponsesStreamEvent::OutputItemAdded {
1462 output_index: 0,
1463 sequence_number: None,
1464 item: response_item_message("msg_123"),
1465 },
1466 ResponsesStreamEvent::OutputTextDelta {
1467 item_id: "msg_123".into(),
1468 output_index: 0,
1469 content_index: Some(0),
1470 delta: "Hello".into(),
1471 },
1472 ResponsesStreamEvent::Completed {
1473 response: ResponseSummary {
1474 usage: Some(ResponseUsage {
1475 input_tokens: Some(5),
1476 output_tokens: Some(3),
1477 total_tokens: Some(8),
1478 }),
1479 ..Default::default()
1480 },
1481 },
1482 ];
1483
1484 let mapped = map_response_events(events);
1485 assert!(matches!(
1486 mapped[0],
1487 LanguageModelCompletionEvent::StartMessage { ref message_id } if message_id == "msg_123"
1488 ));
1489 assert!(matches!(
1490 mapped[1],
1491 LanguageModelCompletionEvent::Text(ref text) if text == "Hello"
1492 ));
1493 assert!(matches!(
1494 mapped[2],
1495 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1496 input_tokens: 5,
1497 output_tokens: 3,
1498 ..
1499 })
1500 ));
1501 assert!(matches!(
1502 mapped[3],
1503 LanguageModelCompletionEvent::Stop(StopReason::EndTurn)
1504 ));
1505 }
1506
1507 #[test]
1508 fn into_open_ai_response_builds_complete_payload() {
1509 let tool_call_id = LanguageModelToolUseId::from("call-42");
1510 let tool_input = json!({ "city": "Boston" });
1511 let tool_arguments = serde_json::to_string(&tool_input).unwrap();
1512 let tool_use = LanguageModelToolUse {
1513 id: tool_call_id.clone(),
1514 name: Arc::from("get_weather"),
1515 raw_input: tool_arguments.clone(),
1516 input: tool_input,
1517 is_input_complete: true,
1518 thought_signature: None,
1519 };
1520 let tool_result = LanguageModelToolResult {
1521 tool_use_id: tool_call_id,
1522 tool_name: Arc::from("get_weather"),
1523 is_error: false,
1524 content: LanguageModelToolResultContent::Text(Arc::from("Sunny")),
1525 output: Some(json!({ "forecast": "Sunny" })),
1526 };
1527 let user_image = LanguageModelImage {
1528 source: SharedString::from("aGVsbG8="),
1529 size: None,
1530 };
1531 let expected_image_url = user_image.to_base64_url();
1532
1533 let request = LanguageModelRequest {
1534 thread_id: Some("thread-123".into()),
1535 prompt_id: None,
1536 intent: None,
1537 messages: vec![
1538 LanguageModelRequestMessage {
1539 role: Role::System,
1540 content: vec![MessageContent::Text("System context".into())],
1541 cache: false,
1542 reasoning_details: None,
1543 },
1544 LanguageModelRequestMessage {
1545 role: Role::User,
1546 content: vec![
1547 MessageContent::Text("Please check the weather.".into()),
1548 MessageContent::Image(user_image),
1549 ],
1550 cache: false,
1551 reasoning_details: None,
1552 },
1553 LanguageModelRequestMessage {
1554 role: Role::Assistant,
1555 content: vec![
1556 MessageContent::Text("Looking that up.".into()),
1557 MessageContent::ToolUse(tool_use),
1558 ],
1559 cache: false,
1560 reasoning_details: None,
1561 },
1562 LanguageModelRequestMessage {
1563 role: Role::Assistant,
1564 content: vec![MessageContent::ToolResult(tool_result)],
1565 cache: false,
1566 reasoning_details: None,
1567 },
1568 ],
1569 tools: vec![LanguageModelRequestTool {
1570 name: "get_weather".into(),
1571 description: "Fetches the weather".into(),
1572 input_schema: json!({ "type": "object" }),
1573 use_input_streaming: false,
1574 }],
1575 tool_choice: Some(LanguageModelToolChoice::Any),
1576 stop: vec!["<STOP>".into()],
1577 temperature: None,
1578 thinking_allowed: false,
1579 thinking_effort: None,
1580 speed: None,
1581 };
1582
1583 let response = into_open_ai_response(
1584 request,
1585 "custom-model",
1586 true,
1587 true,
1588 Some(2048),
1589 Some(ReasoningEffort::Low),
1590 );
1591
1592 let serialized = serde_json::to_value(&response).unwrap();
1593 let expected = json!({
1594 "model": "custom-model",
1595 "input": [
1596 {
1597 "type": "message",
1598 "role": "system",
1599 "content": [
1600 { "type": "input_text", "text": "System context" }
1601 ]
1602 },
1603 {
1604 "type": "message",
1605 "role": "user",
1606 "content": [
1607 { "type": "input_text", "text": "Please check the weather." },
1608 { "type": "input_image", "image_url": expected_image_url }
1609 ]
1610 },
1611 {
1612 "type": "message",
1613 "role": "assistant",
1614 "content": [
1615 { "type": "output_text", "text": "Looking that up.", "annotations": [] }
1616 ]
1617 },
1618 {
1619 "type": "function_call",
1620 "call_id": "call-42",
1621 "name": "get_weather",
1622 "arguments": tool_arguments
1623 },
1624 {
1625 "type": "function_call_output",
1626 "call_id": "call-42",
1627 "output": "{\"forecast\":\"Sunny\"}"
1628 }
1629 ],
1630 "stream": true,
1631 "max_output_tokens": 2048,
1632 "parallel_tool_calls": true,
1633 "tool_choice": "required",
1634 "tools": [
1635 {
1636 "type": "function",
1637 "name": "get_weather",
1638 "description": "Fetches the weather",
1639 "parameters": { "type": "object" }
1640 }
1641 ],
1642 "prompt_cache_key": "thread-123",
1643 "reasoning": { "effort": "low" }
1644 });
1645
1646 assert_eq!(serialized, expected);
1647 }
1648
1649 #[test]
1650 fn responses_stream_maps_tool_calls() {
1651 let events = vec![
1652 ResponsesStreamEvent::OutputItemAdded {
1653 output_index: 0,
1654 sequence_number: None,
1655 item: response_item_function_call("item_fn", Some("{\"city\":\"Bos")),
1656 },
1657 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1658 item_id: "item_fn".into(),
1659 output_index: 0,
1660 delta: "ton\"}".into(),
1661 sequence_number: None,
1662 },
1663 ResponsesStreamEvent::FunctionCallArgumentsDone {
1664 item_id: "item_fn".into(),
1665 output_index: 0,
1666 arguments: "{\"city\":\"Boston\"}".into(),
1667 sequence_number: None,
1668 },
1669 ResponsesStreamEvent::Completed {
1670 response: ResponseSummary::default(),
1671 },
1672 ];
1673
1674 let mapped = map_response_events(events);
1675 assert!(matches!(
1676 mapped[0],
1677 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1678 ref id,
1679 ref name,
1680 ref raw_input,
1681 ..
1682 }) if id.to_string() == "call_123"
1683 && name.as_ref() == "get_weather"
1684 && raw_input == "{\"city\":\"Boston\"}"
1685 ));
1686 assert!(matches!(
1687 mapped[1],
1688 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1689 ));
1690 }
1691
1692 #[test]
1693 fn responses_stream_uses_max_tokens_stop_reason() {
1694 let events = vec![ResponsesStreamEvent::Incomplete {
1695 response: ResponseSummary {
1696 status_details: Some(ResponseStatusDetails {
1697 reason: Some("max_output_tokens".into()),
1698 r#type: Some("incomplete".into()),
1699 error: None,
1700 }),
1701 usage: Some(ResponseUsage {
1702 input_tokens: Some(10),
1703 output_tokens: Some(20),
1704 total_tokens: Some(30),
1705 }),
1706 ..Default::default()
1707 },
1708 }];
1709
1710 let mapped = map_response_events(events);
1711 assert!(matches!(
1712 mapped[0],
1713 LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
1714 input_tokens: 10,
1715 output_tokens: 20,
1716 ..
1717 })
1718 ));
1719 assert!(matches!(
1720 mapped[1],
1721 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1722 ));
1723 }
1724
1725 #[test]
1726 fn responses_stream_handles_multiple_tool_calls() {
1727 let events = vec![
1728 ResponsesStreamEvent::OutputItemAdded {
1729 output_index: 0,
1730 sequence_number: None,
1731 item: response_item_function_call("item_fn1", Some("{\"city\":\"NYC\"}")),
1732 },
1733 ResponsesStreamEvent::FunctionCallArgumentsDone {
1734 item_id: "item_fn1".into(),
1735 output_index: 0,
1736 arguments: "{\"city\":\"NYC\"}".into(),
1737 sequence_number: None,
1738 },
1739 ResponsesStreamEvent::OutputItemAdded {
1740 output_index: 1,
1741 sequence_number: None,
1742 item: response_item_function_call("item_fn2", Some("{\"city\":\"LA\"}")),
1743 },
1744 ResponsesStreamEvent::FunctionCallArgumentsDone {
1745 item_id: "item_fn2".into(),
1746 output_index: 1,
1747 arguments: "{\"city\":\"LA\"}".into(),
1748 sequence_number: None,
1749 },
1750 ResponsesStreamEvent::Completed {
1751 response: ResponseSummary::default(),
1752 },
1753 ];
1754
1755 let mapped = map_response_events(events);
1756 assert_eq!(mapped.len(), 3);
1757 assert!(matches!(
1758 mapped[0],
1759 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1760 if raw_input == "{\"city\":\"NYC\"}"
1761 ));
1762 assert!(matches!(
1763 mapped[1],
1764 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1765 if raw_input == "{\"city\":\"LA\"}"
1766 ));
1767 assert!(matches!(
1768 mapped[2],
1769 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1770 ));
1771 }
1772
1773 #[test]
1774 fn responses_stream_handles_mixed_text_and_tool_calls() {
1775 let events = vec![
1776 ResponsesStreamEvent::OutputItemAdded {
1777 output_index: 0,
1778 sequence_number: None,
1779 item: response_item_message("msg_123"),
1780 },
1781 ResponsesStreamEvent::OutputTextDelta {
1782 item_id: "msg_123".into(),
1783 output_index: 0,
1784 content_index: Some(0),
1785 delta: "Let me check that".into(),
1786 },
1787 ResponsesStreamEvent::OutputItemAdded {
1788 output_index: 1,
1789 sequence_number: None,
1790 item: response_item_function_call("item_fn", Some("{\"query\":\"test\"}")),
1791 },
1792 ResponsesStreamEvent::FunctionCallArgumentsDone {
1793 item_id: "item_fn".into(),
1794 output_index: 1,
1795 arguments: "{\"query\":\"test\"}".into(),
1796 sequence_number: None,
1797 },
1798 ResponsesStreamEvent::Completed {
1799 response: ResponseSummary::default(),
1800 },
1801 ];
1802
1803 let mapped = map_response_events(events);
1804 assert!(matches!(
1805 mapped[0],
1806 LanguageModelCompletionEvent::StartMessage { .. }
1807 ));
1808 assert!(matches!(
1809 mapped[1],
1810 LanguageModelCompletionEvent::Text(ref text) if text == "Let me check that"
1811 ));
1812 assert!(matches!(
1813 mapped[2],
1814 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1815 if raw_input == "{\"query\":\"test\"}"
1816 ));
1817 assert!(matches!(
1818 mapped[3],
1819 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1820 ));
1821 }
1822
1823 #[test]
1824 fn responses_stream_handles_json_parse_error() {
1825 let events = vec![
1826 ResponsesStreamEvent::OutputItemAdded {
1827 output_index: 0,
1828 sequence_number: None,
1829 item: response_item_function_call("item_fn", Some("{invalid json")),
1830 },
1831 ResponsesStreamEvent::FunctionCallArgumentsDone {
1832 item_id: "item_fn".into(),
1833 output_index: 0,
1834 arguments: "{invalid json".into(),
1835 sequence_number: None,
1836 },
1837 ResponsesStreamEvent::Completed {
1838 response: ResponseSummary::default(),
1839 },
1840 ];
1841
1842 let mapped = map_response_events(events);
1843 assert!(matches!(
1844 mapped[0],
1845 LanguageModelCompletionEvent::ToolUseJsonParseError {
1846 ref raw_input,
1847 ..
1848 } if raw_input.as_ref() == "{invalid json"
1849 ));
1850 }
1851
1852 #[test]
1853 fn responses_stream_handles_incomplete_function_call() {
1854 let events = vec![
1855 ResponsesStreamEvent::OutputItemAdded {
1856 output_index: 0,
1857 sequence_number: None,
1858 item: response_item_function_call("item_fn", Some("{\"city\":")),
1859 },
1860 ResponsesStreamEvent::FunctionCallArgumentsDelta {
1861 item_id: "item_fn".into(),
1862 output_index: 0,
1863 delta: "\"Boston\"".into(),
1864 sequence_number: None,
1865 },
1866 ResponsesStreamEvent::Incomplete {
1867 response: ResponseSummary {
1868 status_details: Some(ResponseStatusDetails {
1869 reason: Some("max_output_tokens".into()),
1870 r#type: Some("incomplete".into()),
1871 error: None,
1872 }),
1873 output: vec![response_item_function_call(
1874 "item_fn",
1875 Some("{\"city\":\"Boston\"}"),
1876 )],
1877 ..Default::default()
1878 },
1879 },
1880 ];
1881
1882 let mapped = map_response_events(events);
1883 assert!(matches!(
1884 mapped[0],
1885 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1886 if raw_input == "{\"city\":\"Boston\"}"
1887 ));
1888 assert!(matches!(
1889 mapped[1],
1890 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1891 ));
1892 }
1893
1894 #[test]
1895 fn responses_stream_incomplete_does_not_duplicate_tool_calls() {
1896 let events = vec![
1897 ResponsesStreamEvent::OutputItemAdded {
1898 output_index: 0,
1899 sequence_number: None,
1900 item: response_item_function_call("item_fn", Some("{\"city\":\"Boston\"}")),
1901 },
1902 ResponsesStreamEvent::FunctionCallArgumentsDone {
1903 item_id: "item_fn".into(),
1904 output_index: 0,
1905 arguments: "{\"city\":\"Boston\"}".into(),
1906 sequence_number: None,
1907 },
1908 ResponsesStreamEvent::Incomplete {
1909 response: ResponseSummary {
1910 status_details: Some(ResponseStatusDetails {
1911 reason: Some("max_output_tokens".into()),
1912 r#type: Some("incomplete".into()),
1913 error: None,
1914 }),
1915 output: vec![response_item_function_call(
1916 "item_fn",
1917 Some("{\"city\":\"Boston\"}"),
1918 )],
1919 ..Default::default()
1920 },
1921 },
1922 ];
1923
1924 let mapped = map_response_events(events);
1925 assert_eq!(mapped.len(), 2);
1926 assert!(matches!(
1927 mapped[0],
1928 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { ref raw_input, .. })
1929 if raw_input == "{\"city\":\"Boston\"}"
1930 ));
1931 assert!(matches!(
1932 mapped[1],
1933 LanguageModelCompletionEvent::Stop(StopReason::MaxTokens)
1934 ));
1935 }
1936
1937 #[test]
1938 fn responses_stream_handles_empty_tool_arguments() {
1939 // Test that tools with no arguments (empty string) are handled correctly
1940 let events = vec![
1941 ResponsesStreamEvent::OutputItemAdded {
1942 output_index: 0,
1943 sequence_number: None,
1944 item: response_item_function_call("item_fn", Some("")),
1945 },
1946 ResponsesStreamEvent::FunctionCallArgumentsDone {
1947 item_id: "item_fn".into(),
1948 output_index: 0,
1949 arguments: "".into(),
1950 sequence_number: None,
1951 },
1952 ResponsesStreamEvent::Completed {
1953 response: ResponseSummary::default(),
1954 },
1955 ];
1956
1957 let mapped = map_response_events(events);
1958 assert_eq!(mapped.len(), 2);
1959
1960 // Should produce a ToolUse event with an empty object
1961 assert!(matches!(
1962 &mapped[0],
1963 LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
1964 id,
1965 name,
1966 raw_input,
1967 input,
1968 ..
1969 }) if id.to_string() == "call_123"
1970 && name.as_ref() == "get_weather"
1971 && raw_input == ""
1972 && input.is_object()
1973 && input.as_object().unwrap().is_empty()
1974 ));
1975
1976 assert!(matches!(
1977 mapped[1],
1978 LanguageModelCompletionEvent::Stop(StopReason::ToolUse)
1979 ));
1980 }
1981}