| import OpenAI from 'openai' |
| import { createLogger } from '../../shared/logging/logger' |
| import { generateCodeEditPrompt, getRoleSystemPrompt, getSharedModule } from '../../prompts' |
| import type { CustomApiConfig, OutputMode, PromptOverrides, ReferenceImage } from '../../types' |
| import { buildVisionUserMessage } from '../generation/multimodal-input' |
| import { createCustomOpenAIClient } from '../../infrastructure/ai-provider/provider-client-factory' |
| import { createChatCompletionText } from '../openai-stream' |
| import { buildCompletionParams, readMaxCompletionTokens } from '../../infrastructure/ai-provider/completion-policy' |
|
|
| const logger = createLogger('CodeEditService') |
|
|
| const CODER_TEMPERATURE = parseFloat(process.env.AI_TEMPERATURE || '0.7') |
| const MAX_TOKENS = readMaxCompletionTokens() |
| |
| const MAX_CONTENT_ATTEMPTS = 2 |
|
|
| function repairInstruction(reason: string): string { |
| return [ |
| `你上一条修改后的代码有问题（${reason}）。请重新输出完整的修改后 Manim 代码。`, |
| `Your previous edited code was invalid (${reason}). Re-emit the complete edited Manim code.` |
| ].join('\n\n') |
| } |
|
|
| function createCustomClient(config: CustomApiConfig): OpenAI { |
| return createCustomOpenAIClient(config) |
| } |
|
|
| function applyPromptTemplate( |
| template: string, |
| values: Record<string, string>, |
| promptOverrides?: PromptOverrides |
| ): string { |
| let output = template |
|
|
| |
| output = output.replace(/\{\{apiIndexModule\}\}/g, getSharedModule('apiIndex', promptOverrides)) |
| output = output.replace(/\{\{sharedSpecification\}\}/g, getSharedModule('specification', promptOverrides)) |
|
|
| |
| for (const [key, value] of Object.entries(values)) { |
| output = output.replace(new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g'), value || '') |
| } |
| return output |
| } |
|
|
| function extractCodeFromResponse(text: string, outputMode: OutputMode): string { |
| if (!text) return '' |
| const sanitized = text.replace(/<think>[\s\S]*?<\/think>/gi, '') |
| if (outputMode === 'image') { |
| return sanitized.trim() |
| } |
| const anchorMatch = sanitized.match(/### START ###([\s\S]*?)### END ###/) |
| if (anchorMatch) { |
| return anchorMatch[1].trim() |
| } |
| const codeMatch = sanitized.match(/```(?:python)?\n([\s\S]*?)```/i) |
| if (codeMatch) { |
| return codeMatch[1].trim() |
| } |
| return sanitized.trim() |
| } |
|
|
| export async function generateEditedManimCode( |
| concept: string, |
| instructions: string, |
| code: string, |
| outputMode: OutputMode, |
| customApiConfig?: CustomApiConfig, |
| promptOverrides?: PromptOverrides, |
| referenceImages?: ReferenceImage[] |
| ): Promise<string> { |
| if (!customApiConfig) { |
| throw new Error('No upstream AI is configured for this request') |
| } |
| const model = customApiConfig.model?.trim() || '' |
| if (!model) { |
| throw new Error('No model available') |
| } |
| const client = createCustomClient(customApiConfig) |
|
|
| let lastError: Error | undefined |
| try { |
| const baseSystemPrompt = getRoleSystemPrompt('codeEdit', promptOverrides) |
| const userPromptOverride = promptOverrides?.roles?.codeEdit?.user |
| const baseUserPrompt = userPromptOverride |
| ? applyPromptTemplate(userPromptOverride, { concept, instructions, code, outputMode }, promptOverrides) |
| : generateCodeEditPrompt(concept, instructions, code, outputMode) |
| const systemPrompt = baseSystemPrompt |
| const userPrompt = baseUserPrompt |
|
|
| logger.info('开始 AI 修改代码', { concept, outputMode }) |
|
|
| |
| const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [ |
| { role: 'system', content: systemPrompt }, |
| { role: 'user', content: buildVisionUserMessage(userPrompt, referenceImages) } |
| ] |
| const queueContentRepair = (contentAttempt: number, content: string, reason: string): boolean => { |
| if (contentAttempt >= MAX_CONTENT_ATTEMPTS) return false |
| if (content.trim()) messages.push({ role: 'assistant', content }) |
| messages.push({ role: 'user', content: repairInstruction(reason) }) |
| return true |
| } |
|
|
| for (let contentAttempt = 1; contentAttempt <= MAX_CONTENT_ATTEMPTS; contentAttempt += 1) { |
| const { content, mode } = await createChatCompletionText( |
| client, |
| { |
| model, |
| messages, |
| temperature: CODER_TEMPERATURE, |
| ...buildCompletionParams(MAX_TOKENS, undefined, client) |
| }, |
| { |
| fallbackToNonStream: true, |
| usageLabel: contentAttempt === 1 ? 'code-edit' : 'code-edit-repair' |
| } |
| ) |
|
|
| if (!content) { |
| logger.warn('AI 修改返回空内容', { concept, contentAttempt }) |
| const reason = 'AI edit returned empty content' |
| lastError = new Error(reason) |
| logger.warn('AI 修改输出未通过内容检查', { concept, contentAttempt, reason }) |
| if (!queueContentRepair(contentAttempt, content, reason)) break |
| continue |
| } |
|
|
| const extracted = extractCodeFromResponse(content, outputMode) |
| if (!extracted.trim()) { |
| const reason = 'AI edit produced empty code after extraction' |
| lastError = new Error(reason) |
| logger.warn('AI 修改输出未通过内容检查', { concept, contentAttempt, reason }) |
| if (!queueContentRepair(contentAttempt, content, reason)) break |
| continue |
| } |
|
|
| logger.info('AI 修改完成', { |
| concept, |
| outputMode, |
| mode, |
| contentAttempt, |
| length: extracted.length, |
| codePreview: extracted.slice(0, 500) |
| }) |
| return extracted |
| } |
| } catch (error) { |
| lastError = error instanceof Error ? error : new Error(String(error)) |
| if (error instanceof OpenAI.APIError) { |
| logger.error('AI 修改 API 错误', { |
| concept, |
| status: error.status, |
| code: error.code, |
| type: error.type, |
| message: error.message |
| }) |
| } else if (error instanceof Error) { |
| logger.error('AI 修改失败', { concept, errorName: error.name, errorMessage: error.message }) |
| } else { |
| logger.error('AI 修改失败，未知错误', { concept, error: String(error) }) |
| } |
| } |
|
|
| logger.warn('AI 修改最终失败', { |
| concept, |
| attempts: MAX_CONTENT_ATTEMPTS, |
| reason: lastError?.message |
| }) |
| return '' |
| } |
|
|
| export function isCodeEditAvailable(): boolean { |
| return true |
| } |
|
|
