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