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