const prompt = getConversationPairs(
 session.conversationRecords.slice(-config.maxConversationContextLength),
 false,
 )
 
-// Always filter out system messages; for reasoning models, only allow user and assistant
-const promptWithoutSystem = prompt.filter((msg) => msg.role !== 'system')
-const filteredPrompt = isReasoningModel
- ? promptWithoutSystem.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
- : promptWithoutSystem
+// Preserve system messages when supported to avoid losing critical instructions
+let filteredPrompt
+if (isReasoningModel) {
+ // Some reasoning endpoints may not accept system; restrict to user/assistant
+ filteredPrompt = prompt.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
+} else {
+ // Keep all roles, but if duplicates exist, keep the latest system message
+ const lastSystemIndex = [...prompt].reverse().findIndex((m) => m.role === 'system')
+ if (lastSystemIndex !== -1) {
+ const absoluteIndex = prompt.length - 1 - lastSystemIndex
+ filteredPrompt = prompt.filter((m, i) => m.role !== 'system' || i === absoluteIndex)
+ } else {
+ filteredPrompt = prompt
+ }
+}
 
 filteredPrompt.push({ role: 'user', content: question })

 export function isUsingReasoningModel(configOrSession) {
 const modelValue = getModelValue(configOrSession)
 if (!modelValue) return false
 
- // Match o[134] pattern with optional dash and suffix (e.g., o1, o1-preview, o3-mini, o4-mini)
- if (/^o[134](-|$)/.test(modelValue)) {
+ // Consider all "o" family models as reasoning (e.g., o1, o2, o3, o4 and their suffixes)
+ if (modelValue.startsWith('o')) {
 return true
 }
 
 // Match gpt-5* pattern but exclude gpt-5-chat-* variants
 if (modelValue.startsWith('gpt-5') && !modelValue.startsWith('gpt-5-chat')) {
 return true
 }
 
 return false
 }

 if (isReasoningModel) {
 // For reasoning models (non-streaming), get the complete response
 const choice = data.choices?.[0]
 if (!choice) {
 console.debug('No choice in response data for reasoning model')
 return
 }
- const content = choice.message?.content
- if (content) {
+ const content = choice.message?.content ?? choice.text
+ if (content !== undefined && content !== null) {
 answer = content
 port.postMessage({ answer: answer, done: false, session: null })
+ }
+ if (choice.finish_reason || content !== undefined) {
+ // finish once we have a full message or a reported finish
 finish()
 }
 } else {
 // For non-reasoning models (streaming), handle delta content
 const choice = data.choices?.[0]
 if (!choice) {
 console.debug('No choice in response data')
 return
 }
 const delta = choice.delta?.content
 const content = choice.message?.content
 const text = choice.text
 if (delta !== undefined) {
 answer += delta
 } else if (content) {
 answer = content
 } else if (text) {
 answer += text
 }
 port.postMessage({ answer: answer, done: false, session: null })
 
 if (choice.finish_reason) {
 finish()
 return
 }
 }

 export function isUsingReasoningModel(configOrSession) {
 const modelValue = getModelValue(configOrSession)
 if (!modelValue) return false
 
- // Match o[134] pattern with optional dash and suffix (e.g., o1, o1-preview, o3-mini, o4-mini)
- if (/^o[134](-|$)/.test(modelValue)) {
+ // Explicitly match o1, o3, or o4 with optional dash/suffix (e.g., o1, o1-preview, o3-mini, o4-mini)
+ if (/^(o1|o3|o4)(?:-|$)/.test(modelValue)) {
 return true
 }
 
 // Match gpt-5* pattern but exclude gpt-5-chat-* variants
 if (modelValue.startsWith('gpt-5') && !modelValue.startsWith('gpt-5-chat')) {
 return true
 }
 
 return false
 }

 if (isReasoningModel) {
- // Reasoning models use max_completion_tokens instead of max_tokens
+ // Reasoning models: use non-streaming and max_completion_tokens; omit unsupported fields
+ requestBody.stream = false
 requestBody.max_completion_tokens = config.maxResponseTokenLength
- // Reasoning models don't support streaming during beta
- requestBody.stream = false
- // Reasoning models have fixed parameters during beta
- requestBody.temperature = 1
- requestBody.top_p = 1
- requestBody.n = 1
- requestBody.presence_penalty = 0
- requestBody.frequency_penalty = 0
+ delete requestBody.max_tokens
+ delete requestBody.temperature
+ delete requestBody.top_p
+ delete requestBody.n
+ delete requestBody.presence_penalty
+ delete requestBody.frequency_penalty
 } else {
 // Non-reasoning models use the existing behavior
 requestBody.stream = true
 requestBody.max_tokens = config.maxResponseTokenLength
 requestBody.temperature = config.temperature
+ delete requestBody.max_completion_tokens
 }

 const finish = () => {
+ if (finished) return
 finished = true
 pushRecord(session, question, answer)
 console.debug('conversation history', { content: session.conversationRecords })
- port.postMessage({ answer: null, done: true, session: session })
+ port.postMessage({ answer: null, done: true, session })
 }

 if (isReasoningModel) {
- // Reasoning models use max_completion_tokens instead of max_tokens
+ // Remove conflicting fields from extraBody-derived properties
+ delete requestBody.max_tokens
+ delete requestBody.temperature
+ delete requestBody.top_p
+ delete requestBody.n
+ delete requestBody.presence_penalty
+ delete requestBody.frequency_penalty
+ delete requestBody.stream
+
 requestBody.max_completion_tokens = config.maxResponseTokenLength
- // Reasoning models don't support streaming during beta
 requestBody.stream = false
- // Reasoning models have fixed parameters during beta
 requestBody.temperature = 1
 requestBody.top_p = 1
 requestBody.n = 1
 requestBody.presence_penalty = 0
 requestBody.frequency_penalty = 0
 } else {
- // Non-reasoning models use the existing behavior
+ delete requestBody.max_completion_tokens
 requestBody.stream = true
 requestBody.max_tokens = config.maxResponseTokenLength
 requestBody.temperature = config.temperature
 }

+const baseMessages = [...prompt]
 const filteredPrompt = isReasoningModel
- ? prompt.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
- : prompt
+ ? baseMessages.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
+ : baseMessages
 
 filteredPrompt.push({ role: 'user', content: question })

-// Filter out system messages for reasoning models (only user and assistant are allowed)
-const filteredPrompt = isReasoningModel
- ? prompt.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
- : prompt
+let filteredPrompt
+if (isReasoningModel) {
+ const systemText = prompt
+ .filter((m) => m.role === 'system')
+ .map((m) => (typeof m.content === 'string' ? m.content : ''))
+ .filter(Boolean)
+ .join('\n\n')
+ const nonSystem = prompt.filter((m) => m.role === 'user' || m.role === 'assistant')
+ if (systemText) {
+ // Prepend system guidance to the first user turn or to the new question
+ const firstUserIdx = nonSystem.findIndex((m) => m.role === 'user')
+ const prefix = `System instructions:\n${systemText}\n\n`
+ if (firstUserIdx >= 0) {
+ nonSystem[firstUserIdx] = {
+ ...nonSystem[firstUserIdx],
+ content: `${prefix}${nonSystem[firstUserIdx].content || ''}`,
+ }
+ } else {
+ // No prior user content; prepend to outgoing question
+ filteredPrompt = nonSystem
+ filteredPrompt.push({ role: 'user', content: `${prefix}${question}` })
+ // Skip extra push below since we've added the question
+ }
+ }
+ if (!filteredPrompt) {
+ filteredPrompt = nonSystem
+ filteredPrompt.push({ role: 'user', content: question })
+ }
+} else {
+ filteredPrompt = prompt
+ filteredPrompt.push({ role: 'user', content: question })
+}
 
-filteredPrompt.push({ role: 'user', content: question })
-

 if (isReasoningModel) {
- // For reasoning models (non-streaming), get the complete response
 const choice = data.choices?.[0]
 if (!choice) {
 console.debug('No choice in response data for reasoning model')
 return
 }
- const content = choice.message?.content
- if (content) {
+ let content = choice.message?.content
+ if (Array.isArray(content)) {
+ content = content
+ .filter((p) => p?.type === 'text' && typeof p.text === 'string')
+ .map((p) => p.text)
+ .join('')
+ }
+ if (typeof content === 'object') {
+ // Ignore non-text objects (e.g., tool calls)
+ content = ''
+ }
+ if (typeof content === 'string' && content.length > 0) {
 answer = content
 port.postMessage({ answer: answer, done: false, session: null })
 finish()
 }
 } else {
- // For non-reasoning models (streaming), handle delta content
 const choice = data.choices?.[0]
 if (!choice) {
 console.debug('No choice in response data')
 return
 }
- const delta = choice.delta?.content
+ let delta = choice.delta?.content
+ if (Array.isArray(delta)) {
+ delta = delta
+ .filter((p) => p?.type === 'text' && typeof p.text === 'string')
+ .map((p) => p.text)
+ .join('')
+ }
 const content = choice.message?.content
 const text = choice.text
- if (delta !== undefined) {
+ if (typeof delta === 'string') {
 answer += delta
- } else if (content) {
+ } else if (typeof content === 'string') {
 answer = content
- } else if (text) {
+ } else if (typeof text === 'string') {
 answer += text
 }
 port.postMessage({ answer: answer, done: false, session: null })
-
 if (choice.finish_reason) {
 finish()
 return
 }
 }

// src/utils/model-name-convert.mjs
export function isUsingReasoningModel(configOrSession) {
 const modelValue = getModelValue(configOrSession)
 return (
 modelValue === 'o1-preview' ||
 modelValue === 'o1-mini' ||
 modelValue === 'o3-preview' || // Assumes o3, o4, gpt-5 have same limits
 modelValue === 'o3-mini' ||
 modelValue === 'o4-mini' ||
 modelValue === 'gpt-5' // ...and others
 )
}
export function isUsingO1Model(configOrSession) { // Alias for all reasoning models
 return isUsingReasoningModel(configOrSession)
}
// src/services/apis/openai-api.mjs
const isO1Model = isUsingO1Model(session) // This is true for o3, o4, gpt-5
if (isO1Model) {
 // All reasoning models are forced into o1 beta limitations
 requestBody.stream = false
 requestBody.temperature = 1
 // ...
}

// src/utils/model-name-convert.mjs
export function isUsingO1Model(configOrSession) {
 const modelValue = getModelValue(configOrSession)
 return (
 modelValue === 'o1-preview' ||
 modelValue === 'o1-mini'
 )
}
// Add separate checks for other model families if they have unique requirements
// src/services/apis/openai-api.mjs
const isO1 = isUsingO1Model(session) // This is ONLY true for o1 models
if (isO1) {
 // Apply o1-specific beta limitations
 requestBody.stream = false
 requestBody.temperature = 1
 // ...
} else {
 // Default behavior for other models (including o3, o4, gpt-5)
 requestBody.stream = true
 // ...
}

-// Filter out system messages for o1 models (only user and assistant are allowed)
-const filteredPrompt = isO1Model
- ? prompt.filter((msg) => msg.role === 'user' || msg.role === 'assistant')
- : prompt
+// Ensure only valid roles are sent; keep system messages
+const filteredPrompt = (isO1Model ? prompt : prompt).filter(
+ (msg) => msg.role === 'system' || msg.role === 'user' || msg.role === 'assistant'
+)
 
 filteredPrompt.push({ role: 'user', content: question })

 if (isO1Model) {
- // o1 models use max_completion_tokens instead of max_tokens
+ // Reasoning models: use completion tokens limit; avoid unsupported params
 requestBody.max_completion_tokens = config.maxResponseTokenLength
- // o1 models don't support streaming during beta
 requestBody.stream = false
- // o1 models have fixed parameters during beta
- requestBody.temperature = 1
- requestBody.top_p = 1
- requestBody.n = 1
- requestBody.presence_penalty = 0
- requestBody.frequency_penalty = 0
+ delete requestBody.temperature
+ delete requestBody.top_p
+ delete requestBody.n
+ delete requestBody.presence_penalty
+ delete requestBody.frequency_penalty
 } else {
- // Non-o1 models use the existing behavior
 requestBody.stream = true
 requestBody.max_tokens = config.maxResponseTokenLength
 requestBody.temperature = config.temperature
 }

 if (isO1Model) {
- // For o1 models (non-streaming), get the complete response
 const choice = data.choices?.[0]
 if (!choice) {
- console.debug('No choice in response data for o1 model')
+ console.debug('No choice in response data for reasoning model')
 return
 }
- const content = choice.message?.content
- if (content) {
+ const content = choice.message?.content ?? choice.text
+ if (content !== undefined) {
 answer = content
- port.postMessage({ answer: answer, done: false, session: null })
+ port.postMessage({ answer, done: false, session: null })
+ }
+ if (choice.finish_reason) {
 finish()
 }
 } else {
- // For non-o1 models (streaming), handle delta content
 const choice = data.choices?.[0]
 if (!choice) {
 console.debug('No choice in response data')
 return
 }
 const delta = choice.delta?.content
 const content = choice.message?.content
 const text = choice.text
 if (delta !== undefined) {
 answer += delta
 } else if (content) {
 answer = content
 } else if (text) {
 answer += text
 }
- port.postMessage({ answer: answer, done: false, session: null })
+ port.postMessage({ answer, done: false, session: null })
 
 if (choice.finish_reason) {
 finish()
- return
 }
 }