import json import time from types import SimpleNamespace import httpx from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from app.config import settings from app.models.model_config import ModelConfig from app.services.operation_log_service import build_exception_detail, log_ai_model_event from app.services.llm_billing.context import LlmProviderPostprocessError from app.utils.id_gen import generate_id class LLMProviderCallError(RuntimeError): """Remote model call or response validation failed and may use fallback.""" MOCK_OPTIMIZED_PROMPTS = { "直播": "专业直播间场景，45度斜角机位，暖色柔光打光，主播居中构图，背景虚化处理，产品特写切换流畅，镜头推进节奏感强，画面色彩饱和度高，适合电商直播推广视频。", "产品": "高端产品展示视频，360度旋转环绕拍摄，纯白/深色渐变背景，柔光箱打光消除阴影，微距镜头捕捉产品细节，金属/玻璃材质高光反射，品牌Logo水印角落显示。", "课程": "在线教育课程片头，明亮书房环境，讲师半身出镜，板书/屏幕录制无缝切换，字幕条底部滚动，知识要点动画弹出，背景轻音乐辅助，整体色调清新专业。", "美食": "美食制作过程记录，俯拍+侧拍双机位切换，暖色灯光突出食材质感，慢镜头捕捉烹饪瞬间（蒸汽、油花、酱汁淋洒），成品摆盘精致特写，色调偏暖黄增进食欲。", "品牌": "品牌形象宣传片，电影级调色（青橙对比色），航拍+地面多角度取景，城市/自然场景交替，人物情感特写穿插，品牌故事旁白叠加，片尾Logo定版动画。", "游戏": "游戏宣传CG风格视频，高速运镜+粒子特效，角色动态捕捉流畅，技能释放光效炸裂，UI界面模拟叠加，BGM史诗感配乐，画面帧率60fps丝滑体验。", "product": "Premium product showcase video with 360-degree rotation, clean gradient background, professional studio lighting, macro lens capturing fine details, metallic and glass material highlights, brand watermark in corner.", "live": "Professional livestream scene with 45-degree angle camera, warm soft lighting, host centered with bokeh background, smooth product close-up transitions, vibrant saturated colors.", "course": "Online education intro with bright study environment, instructor half-body shot, seamless screen recording transitions, animated key points overlay, clean professional tone.", "food": "Food preparation recording with overhead and side camera switching, warm lighting highlighting textures, slow-motion cooking moments, elegant plating close-up.", "brand": "Cinematic brand film with teal-orange color grading, aerial and ground multi-angle shots, urban and nature scenes alternating, emotional character close-ups, brand story narration.", "game": "Game promotional CG-style video with dynamic camera movements, particle effects, character motion capture, explosive skill light effects, epic BGM, smooth 60fps visuals.", } def _get_default_prompt(prompt: str, gen_type: str = "video") -> tuple[str, dict]: if gen_type == "image": optimized = ( f"Professional high-quality image with expert composition, precise color grading, " f"sharp focus and rich details. Theme: {prompt}. Photographic style with " f"professional lighting and strong visual impact, suitable for commercial use." ) else: optimized = ( f"Professionally crafted video with expert composition, precise color grading, " f"smooth camera movements. Theme: {prompt}. Cinematic shooting techniques with " f"rich lighting layers and strong visual impact, suitable for commercial distribution." ) return optimized, { "input_tokens": 0, "output_tokens": 0, "total_tokens": 0, "usage_reported": True, "billing_free": True, } async def optimize_prompt( db: AsyncSession, original_prompt: str, user_id: str | None = None, industry_key: str | None = None, duration: int | None = None, image_size: str | None = None, image_proportion: str | None = None, image_px: str | None = None, references: list[dict] | None = None, gen_type: str = "video", *, log_module: str = "generation_ai", log_step: str = "prompt_optimize", log_project_id: str | None = None, log_task_id: str | None = None, log_owner_type: str | None = None, log_owner_id: str | None = None, generation_attempt_no: int | None = None, fixed_model_config_id: str | None = None, fixed_model_snapshot: dict | None = None, ) -> tuple[str, dict]: """Optimize user prompt using LLM. Returns (optimized_text, token_usage_dict).""" stmt = select(ModelConfig).where( ModelConfig.is_active.is_(True), ModelConfig.deleted_at.is_(None), ModelConfig.provider != "mock", ) if fixed_model_config_id: stmt = stmt.where(ModelConfig.id == fixed_model_config_id) stmt = stmt.order_by(ModelConfig.priority.desc(), ModelConfig.id.asc()).limit(1) result = await db.execute(stmt) item = result.scalar_one_or_none() if item is None: raise LLMProviderCallError("没有可用的固定LLM模型，本版本禁止Mock、自动切换和降级") snapshot = dict(fixed_model_snapshot or {}) selected = SimpleNamespace( id=item.id, name=snapshot.get("name") or item.name, provider=snapshot.get("provider") or item.provider, api_base=snapshot.get("api_base") or item.api_base, api_key=item.api_key, model_name=snapshot.get("model_name") or item.model_name, max_tokens=snapshot.get("max_tokens") if snapshot.get("max_tokens") is not None else item.max_tokens, temperature=snapshot.get("temperature") if snapshot.get("temperature") is not None else item.temperature, ) await db.commit() if selected.provider not in ("openai_compatible", "sdk"): raise LLMProviderCallError(f"固定模型供应商不受支持：{selected.provider}") return await _call_openai_compatible( selected, original_prompt, db, user_id, industry_key, duration, references=references, gen_type=gen_type, image_size=image_size, image_proportion=image_proportion, image_px=image_px, log_module=log_module, log_step=log_step, log_project_id=log_project_id, log_task_id=log_task_id, log_owner_type=log_owner_type, log_owner_id=log_owner_id, generation_attempt_no=generation_attempt_no, ) def _mock_optimize(prompt: str, gen_type: str = "video") -> tuple[str, dict]: """Return a keyword-matched mock optimized prompt.""" for keyword, optimized in MOCK_OPTIMIZED_PROMPTS.items(): if keyword in prompt: return optimized, { "input_tokens": 0, "output_tokens": 0, "total_tokens": 0, "usage_reported": True, "billing_free": True, } return _get_default_prompt(prompt, gen_type) async def _call_openai_compatible( config: ModelConfig, original_prompt: str, db: AsyncSession | None = None, user_id: str | None = None, industry_key: str | None = None, duration: int | None = None, references: list[dict] | None = None, gen_type: str = "video", image_size: str | None = None, image_proportion: str | None = None, image_px: str | None = None, *, log_module: str = "generation_ai", log_step: str = "prompt_optimize", log_project_id: str | None = None, log_task_id: str | None = None, log_owner_type: str | None = None, log_owner_id: str | None = None, generation_attempt_no: int | None = None, ) -> tuple[str, dict]: """Call an OpenAI-compatible API to optimize the prompt. Returns (content, token_usage).""" system_prompt = None if industry_key and db is not None: from app.models.industry_config import IndustryConfig result = await db.execute( select(IndustryConfig).where(IndustryConfig.key == industry_key).limit(1) ) ind = result.scalar_one_or_none() if ind and ind.skills: try: skills = json.loads(ind.skills) if gen_type == "image": skill_keys = ("文图理解生成图片提示词", "文图理解生成图片", "文图理解") else: skill_keys = ("文图理解生成视频提示词", "文图理解") for s in skills: if s.get("key") in skill_keys and s.get("label"): system_prompt = s["label"] break except (json.JSONDecodeError, TypeError): pass await db.commit() if not system_prompt: if gen_type == "image": system_prompt = ( "你是一位专业的摄影师和图像创作专家。请根据用户提供的主题，" "生成一段详细的、专业的图片生成提示词。要求：\n" "1. 包含具体的画面构图\n" "2. 描述光影效果和色调\n" "3. 指定拍摄角度和镜头类型\n" "4. 画面风格和质感\n" "5. 整体不超过200字" ) else: system_prompt = ( "你是一位专业的视频导演和文案专家。请根据用户提供的视频主题，" "生成一段详细的、专业的视频生成提示词。要求：\n" "1. 包含具体的镜头语言（机位、运镜方式）\n" "2. 描述光影效果和色调\n" "3. 画面构图和视觉层次\n" "4. 适合的节奏感和转场\n" "5. 整体不超过200字" ) if gen_type == "video" and duration: system_prompt += f"\n\n请根据视频总时长{duration}秒，合理分配镜头节奏，生成适合{duration}秒视频的提示词。" user_content = f"{original_prompt}\n\n请生成一段{duration}秒的视频提示词。" elif gen_type == "image" and image_size: system_prompt += f"\n\n请根据画面分辨率:{image_size}，宽高比:{image_proportion}，宽高像素值:{image_px}，生成适合该分辨率的图片提示词。" user_content = f"{original_prompt}\n\n请生成适合分辨率:{image_size}，宽高比:{image_proportion}，宽高像素值:{image_px}的图片提示词。" else: user_content = original_prompt # Build multimodal user message content when images are present image_urls = [] video_urls = [] if references: for ref in references: if not isinstance(ref, dict): continue ref_type = ref.get("type") ref_url = ref.get("url") if not ref_url: continue if ref_type == "image": image_urls.append(ref_url) if ref_type == "video": video_urls.append(ref_url) async def _build_multimodal_content( user_content: str, image_urls: list[str], video_urls: list[str], *, as_base64: bool, ) -> tuple[dict, dict | None]: """构建多模态 user_message。返回 (actual_message, log_message)。""" from app.utils.media import media_to_base64 content_parts = [{"type": "text", "text": user_content}] for img in image_urls: if as_base64: url = await media_to_base64(img, "image/png") else: url = _file_url_or_data_uri(img, "image/png") content_parts.append({ "type": "image_url", "image_url": {"url": url}, }) for video in video_urls: if as_base64: url = await media_to_base64(video, "video/mp4") else: url = _file_url_or_data_uri(video, "video/mp4") content_parts.append({ "type": "video_url", "video_url": {"url": url}, }) user_message = { "role": "user", "content": content_parts, } # Log-friendly version: keep original paths instead of base64 log_content_parts = [{"type": "text", "text": user_content}] for img in image_urls: log_content_parts.append({ "type": "image_url", "image_url": {"url": img}, }) for video in video_urls: log_content_parts.append({ "type": "video_url", "video_url": {"url": video}, }) log_user_message = { "role": "user", "content": log_content_parts, } return user_message, log_user_message def _file_url_or_data_uri(file_url: str, fallback_mime: str) -> str: """ 远程 URL 保持原样；本地上传路径拼接 BASE_URL 转为完整链接。 """ if file_url.startswith(("http://", "https://", "data:")): return file_url # 本地上传路径拼接 BASE_URL，例如 /uploads/images/xxx.png → https://domain.com/uploads/images/xxx.png base = settings.BASE_URL.rstrip("/") path = file_url if file_url.startswith("/") else f"/{file_url}" return f"{base}{path}" if image_urls or video_urls: from app.utils.media import get_llm_media_as_base64 as_base64 = await get_llm_media_as_base64(db) # 配置读取后立即结束事务；后续 URL 下载/Base64 转换属于外部 I/O， # 不能继续占用数据库连接。 if db is not None: await db.commit() user_message, log_user_message = await _build_multimodal_content( user_content, image_urls, video_urls, as_base64=as_base64, ) else: user_message = { "role": "user", "content": user_content, } log_user_message = None # 防御性结束可能由配置读取开启的只读事务；HTTP 请求期间不占用数据库连接。 if db is not None: await db.commit() async with httpx.AsyncClient(timeout=120) as client: request_data = { "model": config.model_name, "messages": [ {"role": "system", "content": system_prompt}, user_message, ], "max_tokens": config.max_tokens, "temperature": config.temperature, } call_id = generate_id() started = time.perf_counter() common_log = { "module": log_module, "step_code": log_step, "call_id": call_id, "source": "app.services.llm", "user_id": user_id, "project_id": log_project_id, "task_id": log_task_id, "owner_type": log_owner_type, "owner_id": log_owner_id, "generation_attempt_no": generation_attempt_no, "model_config_id": config.id, "model_config_name": config.name, "model_name": config.model_name, "provider": config.provider, "api_base": config.api_base, "remote_action": "chat_completions", } log_ai_model_event( event_type="REQUEST", event_phase="REQUEST", event_status="started", request=request_data, **common_log, ) try: response = await client.post( f"{config.api_base}/chat/completions", headers={ "Authorization": f"Bearer {config.api_key}", "Content-Type": "application/json", }, json=request_data, ) latency_ms = int((time.perf_counter() - started) * 1000) if response.status_code >= 400: error_body = response.text log_ai_model_event( event_type="RESPONSE", event_phase="RESPONSE", event_status="failed", http_status=response.status_code, latency_ms=latency_ms, response={"body": error_body}, error=f"HTTP {response.status_code}", **common_log, ) error = LLMProviderCallError(f"HTTP {response.status_code}: {error_body}") log_ai_model_event( event_type="ERROR", event_phase="ERROR", event_status="failed", http_status=response.status_code, latency_ms=latency_ms, detail=build_exception_detail(error), error=str(error), **common_log, ) raise error data = response.json() log_ai_model_event( event_type="RESPONSE", event_phase="RESPONSE", event_status="success", http_status=response.status_code, latency_ms=latency_ms, response=data, token_usage=data.get("usage") if isinstance(data, dict) else None, **common_log, ) except LLMProviderCallError: raise except Exception as exc: latency_ms = int((time.perf_counter() - started) * 1000) log_ai_model_event( event_type="ERROR", event_phase="ERROR", event_status="failed", latency_ms=latency_ms, detail=build_exception_detail(exc), error=str(exc), **common_log, ) raise LLMProviderCallError(f"{type(exc).__name__}: {exc}") from exc raw_usage = data.get("usage") if isinstance(data, dict) else None usage_reported = bool( isinstance(raw_usage, dict) and any(key in raw_usage for key in ("prompt_tokens", "completion_tokens", "total_tokens")) ) usage = raw_usage if isinstance(raw_usage, dict) else {} input_tokens = int(usage.get("prompt_tokens", 0) or 0) output_tokens = int(usage.get("completion_tokens", 0) or 0) total_tokens = int(usage.get("total_tokens", input_tokens + output_tokens) or 0) token_usage = { "model_config_id": config.id, "model_config_name": config.name, "model_provider": config.provider, "model_name": config.model_name, "source_module": log_module, "source_step_code": log_step, "input_tokens": input_tokens, "output_tokens": output_tokens, "total_tokens": total_tokens, "usage_reported": usage_reported, } try: content = data["choices"][0]["message"]["content"].strip() if not content: raise ValueError("模型未返回有效提示词") except Exception as exc: log_ai_model_event( event_type="ERROR", event_phase="ERROR", event_status="failed", latency_ms=int((time.perf_counter() - started) * 1000), detail=build_exception_detail(exc, {"stage": "response_validation"}), error=str(exc), **common_log, ) raise LlmProviderPostprocessError(f"模型响应解析失败: {exc}", usage=token_usage) from exc return content, token_usage