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