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