Add native Anthropic Messages and OpenAI Responses request formatting with provider-specific reasoning effort and streaming support

- for anthropic, use its native api, not an openai compatibility layer (this way we can enable thinking effort and receive reasoning summaries)
- when using anthropic, we get [Pasted text]
- similarly to anthropic, openai should use the native api, so that 'thinking' is reported to the user
- 'thinking' summaries are never received/reported to the user when using openai, though responses do arrive
- remove redundant comments fom edits: [Changes]

├── apps
│   └── editor
│       ├── package.json
│       └── src
│           ├── commands
│           │   ├── code-at-cursor-command
│           │   │   └── utils
│           │   │       └── perform-code-at-cursor.ts
│           │   └── generate-commit-message-commands
│           │       └── utils
│           │           └── generate-commit-message-with-api.ts
│           ├── constants
│           │   └── providers.ts
│           ├── features
│           │   └── search-files
│           │       └── utils
│           │           └── search-files-by-intelligent.ts
│           ├── i18n
│           │   └── translations
│           │       └── utils
│           │           └── send-llm-message.ts
│           ├── services
│           │   ├── model-fetcher.ts
│           │   ├── prompt-view-api-calls-manager.ts
│           │   └── providers-manager.ts
│           ├── utils
│           │   ├── apply-reasoning-effort.ts
│           │   ├── build-chat-request.ts
│           │   ├── build-request-headers.ts
│           │   ├── build-user-content.ts
│           │   └── send-llm-message.ts
│           └── views
│               ├── chats
│               │   ├── backend
│               │   │   ├── chats-view-provider.ts
│               │   │   └── message-handlers
│               │   │       └── handle-get-chats.ts
│               │   ├── frontend
│               │   │   └── Chats.tsx
│               │   └── types
│               │       └── messages.ts
│               ├── prompt
│               │   └── backend
│               │       └── message-handlers
│               │           ├── configurations
│               │           │   └── handle-pick-api-reasoning-effort.ts
│               │           ├── handle-make-api-call.ts
│               │           ├── handle-patch-repair.ts
│               │           ├── handle-voice-input.ts
│               │           └── utils
│               │               └── patch-repair-utils.ts
│               ├── settings
│               │   ├── backend
│               │   │   └── message-handlers
│               │   │       └── handle-pick-api-reasoning-effort.ts
│               │   └── frontend
│               │       └── forms
│               │           └── EditProviderForm
│               │               └── EditProviderForm.tsx
│               └── shared
│                   └── actions
│                       └── api
│                           ├── create
│                           │   └── interactions
│                           │       ├── verify-model.ts
│                           │       └── verify-reasoning-effort.ts
│                           └── update
│                               └── interactions
│                                   └── edit-reasoning-effort-for-api-config.ts
└── packages
    └── ui
        └── src
            └── components
                └── editor
                    └── chats-view
                        ├── Chats
                        │   └── Chats.tsx
                        └── Progress
                            └── Progress.tsx

Author: robertpiosik

apps/editor/src/services/prompt-view-api-calls-manager.ts

@@ -43,6 +43,8 @@ export class PromptViewApiCallsManager {
     const body_to_hash = JSON.parse(JSON.stringify(params.body))
     delete body_to_hash.reasoning_effort
     delete body_to_hash.reasoning
+    delete body_to_hash.thinking
+    delete body_to_hash.output_config
     if (body_to_hash.extra_body?.google?.thinking_config) {
       delete body_to_hash.extra_body.google.thinking_config
     }

apps/editor/src/utils/apply-reasoning-effort.ts

@@ -1,4 +1,5 @@
 import { ApiConfiguration, Provider } from '@/services/providers-manager'
+import { PROVIDERS } from '@/constants/providers'
 
 export const apply_reasoning_effort = (params: {
   body: { [key: string]: any }
@@ -17,14 +18,30 @@ export const apply_reasoning_effort = (params: {
     params.provider.base_url ==
     'https://generativelanguage.googleapis.com/v1beta/openai/v1'
   ) {
-    params.body.extra_body = {
-      google: {
-        thinking_config: {
-          thinking_level: params.reasoning_effort,
-          include_thoughts: true
+    if (params.reasoning_effort) {
+      params.body.extra_body = {
+        google: {
+          thinking_config: {
+            thinking_level: params.reasoning_effort,
+            include_thoughts: true
+          }
         }
       }
     }
+  } else if (params.provider.base_url === PROVIDERS.Anthropic.base_url) {
+    if (params.reasoning_effort === 'none') {
+      params.body.thinking = { type: 'disabled' }
+    } else if (params.reasoning_effort) {
+      params.body.thinking = { type: 'adaptive', display: 'summarized' }
+      params.body.output_config = { effort: params.reasoning_effort }
+    }
+  } else if (params.provider.base_url === PROVIDERS.OpenAI.base_url) {
+    if (params.reasoning_effort) {
+      params.body.reasoning =
+        params.reasoning_effort === 'none'
+          ? { effort: 'none' }
+          : { effort: params.reasoning_effort, summary: 'auto' }
+    }
   } else {
     if (params.reasoning_effort) {
       params.body.reasoning_effort = params.reasoning_effort

apps/editor/src/utils/build-chat-request.ts

@@ -0,0 +1,136 @@
+import { PROVIDERS } from '@/constants/providers'
+
+const ANTHROPIC_MAX_TOKENS = 64000
+
+export type ChatApiFormat =
+  | 'chat-completions'
+  | 'anthropic-messages'
+  | 'openai-responses'
+
+export const is_anthropic_base_url = (base_url: string): boolean =>
+  base_url === PROVIDERS.Anthropic.base_url
+
+export const is_openai_base_url = (base_url: string): boolean =>
+  base_url === PROVIDERS.OpenAI.base_url
+
+const get_text_from_content = (content: any): string => {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content
+      .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+      .map((part) => part.text)
+      .join('\n\n')
+  }
+  return ''
+}
+
+const has_audio_input = (messages: any[]): boolean =>
+  messages.some(
+    (message) =>
+      Array.isArray(message?.content) &&
+      message.content.some((part: any) => part?.type === 'input_audio')
+  )
+
+const to_responses_content = (content: any): any => {
+  if (!Array.isArray(content)) return content
+  return content.map((part) => {
+    if (part?.type === 'text') {
+      return { ...part, type: 'input_text' }
+    }
+    if (part?.type === 'image_url') {
+      const { image_url, ...rest } = part
+      return {
+        ...rest,
+        type: 'input_image',
+        image_url: typeof image_url === 'string' ? image_url : image_url?.url
+      }
+    }
+    return part
+  })
+}
+
+const build_openai_responses_request = (params: {
+  base_url: string
+  body: { [key: string]: any }
+}): { url: string; body: { [key: string]: any }; format: ChatApiFormat } => {
+  const { messages = [], ...rest } = params.body
+  const instructions_parts: string[] = []
+  const input: any[] = []
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      const text = get_text_from_content(message.content)
+      if (text) instructions_parts.push(text)
+    } else {
+      input.push({
+        role: message.role,
+        content: to_responses_content(message.content)
+      })
+    }
+  }
+
+  return {
+    url: `${params.base_url}/responses`,
+    body: {
+      store: false,
+      ...rest,
+      ...(instructions_parts.length > 0
+        ? { instructions: instructions_parts.join('\n\n') }
+        : {}),
+      input
+    },
+    format: 'openai-responses'
+  }
+}
+
+export const build_chat_request = (params: {
+  base_url: string
+  body: { [key: string]: any }
+}): { url: string; body: { [key: string]: any }; format: ChatApiFormat } => {
+  if (is_openai_base_url(params.base_url)) {
+    if (!has_audio_input(params.body.messages ?? [])) {
+      return build_openai_responses_request(params)
+    }
+
+    const { reasoning, ...rest } = params.body
+    return {
+      url: `${params.base_url}/chat/completions`,
+      body: reasoning?.effort
+        ? { ...rest, reasoning_effort: reasoning.effort }
+        : rest,
+      format: 'chat-completions'
+    }
+  }
+
+  if (!is_anthropic_base_url(params.base_url)) {
+    return {
+      url: `${params.base_url}/chat/completions`,
+      body: params.body,
+      format: 'chat-completions'
+    }
+  }
+
+  const { messages = [], ...rest } = params.body
+  const system_parts: string[] = []
+  const native_messages: any[] = []
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      const text = get_text_from_content(message.content)
+      if (text) system_parts.push(text)
+    } else {
+      native_messages.push(message)
+    }
+  }
+
+  return {
+    url: `${params.base_url}/messages`,
+    body: {
+      max_tokens: ANTHROPIC_MAX_TOKENS,
+      ...rest,
+      ...(system_parts.length > 0 ? { system: system_parts.join('\n\n') } : {}),
+      messages: native_messages
+    },
+    format: 'anthropic-messages'
+  }
+}

apps/editor/src/utils/build-user-content.ts

@@ -6,6 +6,9 @@ export const build_user_content = (params: {
   part1: string
   part2: string
 }): any => {
+  const is_anthropic = params.provider.base_url === PROVIDERS.Anthropic.base_url
+  const is_openai = params.provider.base_url === PROVIDERS.OpenAI.base_url
+
   const parse_text_with_images = (text: string) => {
     if (!text.includes('<cwc-image>')) {
       return [{ type: 'text', text }]
@@ -19,20 +22,28 @@ export const build_user_content = (params: {
           parsed.push({ type: 'text', text: part.trim() })
         }
       } else {
-        parsed.push({
-          type: 'image_url',
-          image_url: {
-            url: `data:image/png;base64,${part}`
-          }
-        })
+        parsed.push(
+          is_anthropic
+            ? {
+                type: 'image',
+                source: {
+                  type: 'base64',
+                  media_type: 'image/png',
+                  data: part
+                }
+              }
+            : {
+                type: 'image_url',
+                image_url: {
+                  url: `data:image/png;base64,${part}`
+                }
+              }
+        )
       }
     }
     return parsed
   }
 
-  const is_anthropic = params.provider.base_url === PROVIDERS.Anthropic.base_url
-  const is_openai = params.provider.base_url === PROVIDERS.OpenAI.base_url
-
   if (is_anthropic || is_openai) {
     const cache_config: any = {}
 
@@ -48,18 +59,26 @@ export const build_user_content = (params: {
       }
     }
 
-    const user_content: any[] = [
-      {
+    const user_content: any[] = []
+
+    if (params.part1.trim()) {
+      user_content.push({
         type: 'text',
         text: params.part1,
         ...cache_config
-      }
-    ]
+      })
+    }
 
     if (!params.part2.includes('<cwc-image>')) {
-      user_content.push({ type: 'text', text: params.part2 })
+      if (params.part2.trim()) {
+        user_content.push({ type: 'text', text: params.part2 })
+      }
     } else {
-      user_content.push(...parse_text_with_images(params.part2))
+      user_content.push(
+        ...parse_text_with_images(params.part2).filter(
+          (part) => part.type !== 'text' || part.text.trim()
+        )
+      )
     }
 
     return user_content