run prettier on convert-to-openai-compatible-chat-messages

Author: charleslien

packages/internal/src/openai-compatible/chat/convert-to-openai-compatible-chat-messages.ts

@@ -1,27 +1,28 @@
-import {
+import { UnsupportedFunctionalityError } from '@ai-sdk/provider'
+import { convertToBase64 } from '@ai-sdk/provider-utils'
+
+import type { OpenAICompatibleChatPrompt } from './openai-compatible-api-types'
+import type {
   LanguageModelV2Prompt,
   SharedV2ProviderMetadata,
-  UnsupportedFunctionalityError,
-} from '@ai-sdk/provider';
-import { OpenAICompatibleChatPrompt } from './openai-compatible-api-types';
-import { convertToBase64 } from '@ai-sdk/provider-utils';
+} from '@ai-sdk/provider'
 
 function getOpenAIMetadata(message: {
-  providerOptions?: SharedV2ProviderMetadata;
+  providerOptions?: SharedV2ProviderMetadata
 }) {
-  return message?.providerOptions?.openaiCompatible ?? {};
+  return message?.providerOptions?.openaiCompatible ?? {}
 }
 
 export function convertToOpenAICompatibleChatMessages(
   prompt: LanguageModelV2Prompt,
 ): OpenAICompatibleChatPrompt {
-  const messages: OpenAICompatibleChatPrompt = [];
+  const messages: OpenAICompatibleChatPrompt = []
   for (const { role, content, ...message } of prompt) {
-    const metadata = getOpenAIMetadata({ ...message });
+    const metadata = getOpenAIMetadata({ ...message })
     switch (role) {
       case 'system': {
-        messages.push({ role: 'system', content, ...metadata });
-        break;
+        messages.push({ role: 'system', content, ...metadata })
+        break
       }
 
       case 'user': {
@@ -30,24 +31,22 @@ export function convertToOpenAICompatibleChatMessages(
             role: 'user',
             content: content[0].text,
             ...getOpenAIMetadata(content[0]),
-          });
-          break;
+          })
+          break
         }
 
         messages.push({
           role: 'user',
-          content: content.map(part => {
-            const partMetadata = getOpenAIMetadata(part);
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part)
             switch (part.type) {
               case 'text': {
-                return { type: 'text', text: part.text, ...partMetadata };
+                return { type: 'text', text: part.text, ...partMetadata }
               }
               case 'file': {
                 if (part.mediaType.startsWith('image/')) {
                   const mediaType =
-                    part.mediaType === 'image/*'
-                      ? 'image/jpeg'
-                      : part.mediaType;
+                    part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType
 
                   return {
                     type: 'image_url',
@@ -58,35 +57,35 @@ export function convertToOpenAICompatibleChatMessages(
                           : `data:${mediaType};base64,${convertToBase64(part.data)}`,
                     },
                     ...partMetadata,
-                  };
+                  }
                 } else {
                   throw new UnsupportedFunctionalityError({
                     functionality: `file part media type ${part.mediaType}`,
-                  });
+                  })
                 }
               }
             }
           }),
           ...metadata,
-        });
+        })
 
-        break;
+        break
       }
 
       case 'assistant': {
-        let text = '';
+        let text = ''
         const toolCalls: Array<{
-          id: string;
-          type: 'function';
-          function: { name: string; arguments: string };
-        }> = [];
+          id: string
+          type: 'function'
+          function: { name: string; arguments: string }
+        }> = []
 
         for (const part of content) {
-          const partMetadata = getOpenAIMetadata(part);
+          const partMetadata = getOpenAIMetadata(part)
           switch (part.type) {
             case 'text': {
-              text += part.text;
-              break;
+              text += part.text
+              break
             }
             case 'tool-call': {
               toolCalls.push({
@@ -97,8 +96,8 @@ export function convertToOpenAICompatibleChatMessages(
                   arguments: JSON.stringify(part.input),
                 },
                 ...partMetadata,
-              });
-              break;
+              })
+              break
             }
           }
         }
@@ -108,45 +107,45 @@ export function convertToOpenAICompatibleChatMessages(
           content: text,
           tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
           ...metadata,
-        });
+        })
 
-        break;
+        break
       }
 
       case 'tool': {
         for (const toolResponse of content) {
-          const output = toolResponse.output;
+          const output = toolResponse.output
 
-          let contentValue: string;
+          let contentValue: string
           switch (output.type) {
             case 'text':
             case 'error-text':
-              contentValue = output.value;
-              break;
+              contentValue = output.value
+              break
             case 'content':
             case 'json':
             case 'error-json':
-              contentValue = JSON.stringify(output.value);
-              break;
+              contentValue = JSON.stringify(output.value)
+              break
           }
 
-          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse)
           messages.push({
             role: 'tool',
             tool_call_id: toolResponse.toolCallId,
             content: contentValue,
             ...toolResponseMetadata,
-          });
+          })
         }
-        break;
+        break
       }
 
       default: {
-        const _exhaustiveCheck: never = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+        const _exhaustiveCheck: never = role
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`)
       }
     }
   }
 
-  return messages;
+  return messages
 }