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