from __future__ import annotations import mimetypes from decimal import Decimal, ROUND_HALF_UP from typing import Any from fastapi import APIRouter, Header, HTTPException, Request from fastapi.concurrency import run_in_threadpool from fastapi.responses import FileResponse, StreamingResponse from pydantic import BaseModel, ConfigDict, Field from curl_cffi import requests as curl_requests from api.image_inputs import parse_image_edit_request, read_image_sources from api.support import require_identity, resolve_image_base_url from services.auth_service import DAILY_GIFT_ACCOUNT_POOL_MODEL_ID, auth_service from services.chat_model_service import resolve_chat_models from services.image_model_service import resolve_image_models from services.system_model_service import resolve_system_models from services.content_filter import check_request, request_text from services.config import config from services.editable_file_task_service import editable_file_task_service from services.image_annotation_service import identify_image_region from services.log_service import LoggedCall from services.pool_pricing_service import pool_pricing_service from services.skill_service import skill_service from services.protocol import ( anthropic_v1_messages, openai_v1_chat_complete, openai_v1_image_edit, openai_v1_image_generations, openai_v1_models, openai_v1_response, openai_search, ) from services.third_party_image_service import third_party_image_service from utils.helper import has_response_image_generation_tool, is_image_chat_request, parse_image_count class ImageGenerationRequest(BaseModel): prompt: str = Field(..., min_length=1) model: str = "gpt-image-2" n: int = Field(default=1, ge=1, le=4) size: str | None = None quality: str | None = None resolution: str | None = None image_resolution: str | None = None third_party_image_group_id: str | None = None response_format: str = "url" account_pool_strategy: str = "own_first" history_disabled: bool = True stream: bool | None = None class ChatCompletionRequest(BaseModel): model_config = ConfigDict(extra="allow") model: str | None = None prompt: str | None = None n: int | None = None stream: bool | None = None modalities: list[str] | None = None messages: list[dict[str, object]] | None = None class ResponseCreateRequest(BaseModel): model_config = ConfigDict(extra="allow") model: str | None = None input: object | None = None tools: list[dict[str, object]] | None = None tool_choice: object | None = None stream: bool | None = None class AnthropicMessageRequest(BaseModel): model_config = ConfigDict(extra="allow") model: str | None = None messages: list[dict[str, object]] | None = None system: object | None = None stream: bool | None = None class PromptOptimizationRequest(BaseModel): prompt: str = Field(..., min_length=1, max_length=30000) class ReversePromptRequest(BaseModel): image: str = Field(..., min_length=1, max_length=40_000_000) class ImageRegionBounds(BaseModel): x: float = Field(..., ge=0, le=100) y: float = Field(..., ge=0, le=100) width: float = Field(..., gt=0, le=100) height: float = Field(..., gt=0, le=100) class ImageRegionRecognitionRequest(BaseModel): image: str = Field(..., min_length=1, max_length=40_000_000) bounds: ImageRegionBounds class SearchRequest(BaseModel): prompt: str = Field(..., min_length=1) class EditableFileTaskRequest(BaseModel): prompt: str = "" base64_images: list[str] = Field(default_factory=list) client_task_id: str | None = None async def filter_or_log(call: LoggedCall, text: str) -> None: try: await run_in_threadpool(check_request, text) except HTTPException as exc: call.log("调用失败", status="failed", error=str(exc.detail)) raise def _to_positive_image_count(value: object, default: int = 1) -> int: try: return max(1, int(value or default)) except (TypeError, ValueError): return default def _credit_amount(value: object) -> int | float: try: amount = max(Decimal("0"), Decimal(str(value or 0))).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) except Exception: amount = Decimal("0") return int(amount) if amount == amount.to_integral_value() else float(amount) def _third_party_activity_quote(identity: dict[str, object], quantity: int, *, group_id: str, base_unit_price: object) -> dict[str, object]: pricing_config = config.normal_user_third_party_image_pricing if str(identity.get("role") or "").strip().lower() != "normal" or not bool(pricing_config.get("enabled")): base = _credit_amount(base_unit_price) return { "applies": False, "target_type": "third_party_group", "third_party_group_id": group_id, "base_unit_price": base, "pay_percentage": 100, "unit_price": base, "quantity": quantity, "estimated_total": _credit_amount(float(base) * quantity), "rule_id": "", "rule_name": "", } return pool_pricing_service.quote( identity, quantity=quantity, pricing_config=pricing_config, target_type="third_party_group", third_party_group_id=group_id, base_unit_price=base_unit_price, ) def _third_party_wallet_remaining(identity: dict[str, object], group_id: str, model_id: str) -> int | float: try: summary = auth_service.credit_summary(identity) except Exception: return 0 wallets = summary.get("third_party_image_wallets") if isinstance(summary, dict) else [] wallet_key = f"{group_id}:{model_id}" wallet_items = wallets if isinstance(wallets, list) else [] balances: list[int | float] = [] for wallet in wallet_items: if not isinstance(wallet, dict): continue if str(wallet.get("id") or "") == wallet_key or ( str(wallet.get("group_id") or "") == group_id and str(wallet.get("model_id") or "").strip() == model_id ): try: balances.append(_credit_amount(wallet.get("remaining"))) except (TypeError, ValueError): balances.append(0) return max(balances) if balances else 0 def _count_data_images(value: object) -> int: if not isinstance(value, list): return 0 return sum( 1 for item in value if isinstance(item, dict) and (str(item.get("b64_json") or "").strip() or str(item.get("url") or "").strip()) ) def _count_image_generation_items(value: object) -> int: if not isinstance(value, list): return 0 count = 0 for item in value: if not isinstance(item, dict): continue if str(item.get("type") or "") == "image_generation_call" and str(item.get("result") or "").strip(): count += 1 return count def _count_data_url_images(text: object) -> int: return str(text or "").count("data:image/") def _count_successful_images(value: object) -> int: if not isinstance(value, dict): return 0 count = _count_data_images(value.get("data")) if count: return count output = value.get("output") count = _count_image_generation_items(output) if count: return count item = value.get("item") if isinstance(item, dict): count = _count_image_generation_items([item]) if count: return count choices = value.get("choices") if isinstance(choices, list): return sum( _count_data_url_images( ((choice.get("message") if isinstance(choice, dict) else {}) or {}).get("content") if isinstance(choice, dict) else "" ) + _count_data_url_images( ((choice.get("delta") if isinstance(choice, dict) else {}) or {}).get("content") if isinstance(choice, dict) else "" ) for choice in choices ) response = value.get("response") if isinstance(response, dict): return _count_successful_images(response) return 0 def _attach_account_pool(payload: dict[str, object], identity: dict[str, object]) -> None: has_personal_pool = identity.get("role") == "admin" or bool(identity.get("account_pool_enabled")) payload["account_owner_id"] = str(identity.get("id") or "").strip() if not has_personal_pool: payload["account_pool_strategy"] = "admin_only" payload["account_allow_shared"] = False return payload["account_pool_strategy"] = str(payload.get("account_pool_strategy") or "own_first") payload["account_allow_shared"] = bool(payload.get("account_allow_shared", True)) def _chat_completion_text(value: object) -> str: if not isinstance(value, dict): return "" choices = value.get("choices") if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict): return "" message = choices[0].get("message") if not isinstance(message, dict): return "" content = message.get("content") if isinstance(content, str): return content.strip() if not isinstance(content, list): return "" return "".join( str(item.get("text") or "") for item in content if isinstance(item, dict) and str(item.get("type") or "") in {"text", "output_text"} ).strip() def _response_text(value: object) -> str: if not isinstance(value, dict): return "" direct = value.get("output_text") if isinstance(direct, str) and direct.strip(): return direct.strip() output = value.get("output") if not isinstance(output, list): return "" parts: list[str] = [] for item in output: if not isinstance(item, dict): continue content = item.get("content") if not isinstance(content, list): continue parts.extend( str(part.get("text") or "") for part in content if isinstance(part, dict) and str(part.get("type") or "") in {"text", "output_text"} ) return "".join(parts).strip() def _split_grants(grants: list[dict[str, object]], amount: int | float) -> tuple[list[dict[str, object]], list[dict[str, object]]]: remaining = Decimal(str(_credit_amount(amount))) used: list[dict[str, object]] = [] refunded: list[dict[str, object]] = [] for grant in grants: if not isinstance(grant, dict): continue grant_amount = Decimal(str(_credit_amount(grant.get("amount")))) grant_id = str(grant.get("id") or "").strip() if not grant_id or grant_amount <= 0: continue take = min(grant_amount, remaining) if take > 0: used.append({"id": grant_id, "amount": _credit_amount(take)}) if grant_amount - take > 0: refunded.append({"id": grant_id, "amount": _credit_amount(grant_amount - take)}) remaining -= take return used, refunded class CreditReservation: def __init__(self, user_id: str = "", amount: int | float = 0): self.user_id = user_id self.amount = _credit_amount(amount) self.daily_amount: int | float = 0 self.paid_amount: int | float = 0 self.package_reservations: list[dict[str, object]] = [] self.grant_reservations: list[dict[str, object]] = [] self.settled = False @classmethod def reserve( cls, identity: dict[str, object], amount: int | float, *, model_id: str = DAILY_GIFT_ACCOUNT_POOL_MODEL_ID, ) -> "CreditReservation": if str(identity.get("role") or "").strip().lower() != "normal": return cls() reservation = cls(str(identity.get("id") or "").strip(), amount) if not reservation.user_id or reservation.amount <= 0: return reservation details = auth_service.reserve_credits( reservation.user_id, reservation.amount, model_id=model_id, ).get("_credit_reservation", {}) if not isinstance(details, dict): details = {} reservation.daily_amount = _credit_amount(details.get("daily")) reservation.paid_amount = _credit_amount(details.get("permanent_paid") if "permanent_paid" in details else details.get("paid")) reservation.package_reservations = details.get("packages") if isinstance(details.get("packages"), list) else [] reservation.grant_reservations = details.get("grants") if isinstance(details.get("grants"), list) else [] return reservation def settle(self, consume_amount: int | float) -> None: if self.settled: return if not self.user_id or self.amount <= 0: self.settled = True return consume_count = _credit_amount(min(float(self.amount), float(_credit_amount(consume_amount)))) daily_to_consume = _credit_amount(min(float(self.daily_amount), float(consume_count))) remaining = _credit_amount(float(consume_count) - float(daily_to_consume)) packages_to_consume, packages_to_refund = _split_grants(self.package_reservations, remaining) remaining = _credit_amount(float(remaining) - sum(float(_credit_amount(item.get("amount"))) for item in packages_to_consume)) grants_to_consume, grants_to_refund = _split_grants(self.grant_reservations, remaining) remaining = _credit_amount(float(remaining) - sum(float(_credit_amount(item.get("amount"))) for item in grants_to_consume)) paid_to_consume = _credit_amount(min(float(self.paid_amount), float(remaining))) daily_to_refund = _credit_amount(float(self.daily_amount) - float(daily_to_consume)) paid_to_refund = _credit_amount(float(self.paid_amount) - float(paid_to_consume)) if consume_count > 0: auth_service.consume_reserved_credits( self.user_id, consume_count, daily_amount=daily_to_consume, paid_amount=paid_to_consume, package_reservations=packages_to_consume, grant_reservations=grants_to_consume, ) refund_count = _credit_amount(float(self.amount) - float(consume_count)) if refund_count > 0: auth_service.refund_reserved_credits( self.user_id, refund_count, daily_amount=daily_to_refund, paid_amount=paid_to_refund, package_reservations=packages_to_refund, grant_reservations=grants_to_refund, ) self.settled = True class InternalImageModelDailyLimitReservation: def __init__(self, *, user_id: str = "", model_id: str = "", amount: int = 0, scope: str = ""): self.user_id = user_id self.model_id = model_id self.amount = max(0, int(amount or 0)) self.scope = scope self.settled = False @classmethod def reserve( cls, identity: dict[str, object], model_id: object, amount: int, ) -> "InternalImageModelDailyLimitReservation": if str(identity.get("role") or "").strip().lower() != "user": return cls() user_id = str(identity.get("id") or "").strip() normalized_model_id = str(model_id or "gpt-image-2").strip() or "gpt-image-2" if not user_id: return cls() result = auth_service.reserve_internal_image_model_daily_limit( user_id, model_id=normalized_model_id, amount=amount, ) reservation = result.get("_internal_image_model_daily_limit_reservation") if isinstance(result, dict) else {} reserved_amount = max(0, int(reservation.get("amount") or 0)) if isinstance(reservation, dict) else 0 reserved_scope = str(reservation.get("scope") or "").strip() if isinstance(reservation, dict) else "" return cls(user_id=user_id, model_id=normalized_model_id, amount=reserved_amount, scope=reserved_scope) def settle(self, success_count: int) -> None: if self.settled: return success_amount = min(self.amount, max(0, int(success_count or 0))) refund_amount = self.amount - success_amount if self.user_id and self.model_id and success_amount > 0: consume_kwargs: dict[str, object] = { "model_id": self.model_id, "amount": success_amount, } if self.scope: consume_kwargs["scope"] = self.scope auth_service.consume_internal_image_model_daily_limit( self.user_id, **consume_kwargs, ) if self.user_id and self.model_id and refund_amount > 0: refund_kwargs: dict[str, object] = { "model_id": self.model_id, "amount": refund_amount, } if self.scope: refund_kwargs["scope"] = self.scope auth_service.refund_internal_image_model_daily_limit( self.user_id, **refund_kwargs, ) self.settled = True class ImageBillingReservation: def __init__( self, *, mode: str = "", user_id: str = "", amount: int | float = 0, per_image_cost: int | float = 1, group_id: str = "", model_id: str = "", credit_reservation: CreditReservation | None = None, internal_limit_reservation: InternalImageModelDailyLimitReservation | None = None, pricing: dict[str, object] | None = None, ): self.mode = mode self.user_id = user_id self.amount = _credit_amount(amount) self.per_image_cost = _credit_amount(per_image_cost) self.group_id = group_id self.model_id = model_id self.credit_reservation = credit_reservation self.internal_limit_reservation = internal_limit_reservation self.pricing = dict(pricing or {}) self.actual = 0 self.refund = 0 self.log_detail: dict[str, object] = {} if self.pricing: self.log_detail.update({ "billing_base_unit_price": self.pricing.get("base_unit_price", 1), "billing_effective_unit_price": self.pricing.get("unit_price", 1), "billing_pay_percentage": self.pricing.get("pay_percentage", 100), "billing_rule_id": self.pricing.get("rule_id", ""), "billing_rule_name": self.pricing.get("rule_name", ""), "billing_estimated": self.pricing.get("estimated_total", self.amount), "billing_actual": 0, "billing_refund": 0, "billing_priced_at": self.pricing.get("priced_at") or self.pricing.get("evaluated_at", ""), }) self.settled = False @classmethod def reserve(cls, identity: dict[str, object], payload: dict[str, object], *, requested_amount: int | None = None) -> "ImageBillingReservation": amount = _to_positive_image_count(requested_amount if requested_amount is not None else payload.get("n"), 1) resolution = str(payload.get("resolution") or payload.get("image_resolution") or "").strip().lower() group_id = str(payload.get("third_party_image_group_id") or "").strip() use_third_party = resolution in {"1k", "2k", "4k"} or bool(group_id) route = None if not use_third_party: find_named_route = getattr(third_party_image_service, "find_named_route", None) route = find_named_route(payload.get("model"), advance=False) if callable(find_named_route) else None use_third_party = route is not None if not use_third_party: model_id = str(payload.get("model") or "gpt-image-2").strip() or "gpt-image-2" is_normal = str(identity.get("role") or "").strip().lower() == "normal" pricing = pool_pricing_service.quote(identity, quantity=amount) if is_normal else {} estimated_total = _credit_amount(pricing.get("estimated_total", amount)) return cls( mode="general", credit_reservation=CreditReservation.reserve( identity, estimated_total, model_id=DAILY_GIFT_ACCOUNT_POOL_MODEL_ID, ), internal_limit_reservation=InternalImageModelDailyLimitReservation.reserve(identity, model_id, amount), amount=estimated_total, per_image_cost=_credit_amount(pricing.get("unit_price", 1)), pricing=pricing, ) require_4k = resolution == "4k" if route is None and str(identity.get("role") or "").strip().lower() == "normal": find_wallet_route = getattr(third_party_image_service, "find_wallet_route_for_identity", None) if callable(find_wallet_route): route = find_wallet_route( identity, payload.get("model"), group_id=group_id, require_4k=require_4k, resolution=resolution, advance=False, ) if route is None: route = third_party_image_service.find_route( payload.get("model"), group_id=group_id, require_4k=require_4k, resolution=resolution or "1k", advance=False, ) if route is None: raise ValueError("No enabled image API model route") try: third_party_image_service.assert_access(identity, route) except PermissionError as exc: raise PermissionError(str(exc)) from exc payload["_third_party_image"] = True payload["_third_party_image_group_id"] = str(route.group.get("id") or "") payload["third_party_image_group_id"] = str(route.group.get("id") or "") payload["resolution"] = str(route.model.get("resolution") or resolution or "1k") per_image_cost = max(0, third_party_image_service.cost_for_route(route, payload.get("quality") or payload.get("image_quality"), 1)) total_cost = per_image_cost * amount group_id = str(route.group.get("id") or "") model_id = str(route.model.get("id") or "") billing_mode = str(route.group.get("billing_mode") or "") if billing_mode == "general_multiplier" and _third_party_wallet_remaining(identity, group_id, model_id) > 0: # A stale group setting must not strand an existing model-specific # dedicated balance. Treat it as "both" until that balance is used. billing_mode = "both" internal_limit_reservation = InternalImageModelDailyLimitReservation.reserve(identity, model_id, amount) if str(identity.get("role") or "").strip().lower() != "normal": return cls( mode=billing_mode, amount=0, per_image_cost=per_image_cost, group_id=group_id, model_id=model_id, internal_limit_reservation=internal_limit_reservation, ) user_id = str(identity.get("id") or "").strip() wallet_pricing = _third_party_activity_quote(identity, amount, group_id=group_id, base_unit_price=1) wallet_total_cost = _credit_amount(wallet_pricing.get("estimated_total", amount)) wallet_unit_cost = _credit_amount(wallet_pricing.get("unit_price", 1)) if billing_mode == "dedicated_wallet" or ( billing_mode == "both" and per_image_cost > 0 and _third_party_wallet_remaining(identity, group_id, model_id) >= wallet_total_cost ): if wallet_total_cost > 0: try: auth_service.reserve_third_party_image_wallet( user_id, group_id=group_id, model_id=model_id, amount=wallet_total_cost, ) except ValueError: if billing_mode != "both": raise else: return cls( mode="dedicated_wallet", user_id=user_id, amount=wallet_total_cost, per_image_cost=wallet_unit_cost, group_id=group_id, model_id=model_id, internal_limit_reservation=internal_limit_reservation, pricing=wallet_pricing, ) else: return cls( mode="dedicated_wallet", user_id=user_id, amount=0, per_image_cost=0, group_id=group_id, model_id=model_id, internal_limit_reservation=internal_limit_reservation, pricing=wallet_pricing, ) credit_pricing = _third_party_activity_quote(identity, amount, group_id=group_id, base_unit_price=per_image_cost) total_cost = _credit_amount(credit_pricing.get("estimated_total", total_cost)) effective_unit_cost = _credit_amount(credit_pricing.get("unit_price", per_image_cost)) return cls( mode=billing_mode if billing_mode == "both" else "general_multiplier", amount=total_cost, per_image_cost=effective_unit_cost, credit_reservation=CreditReservation.reserve( identity, total_cost, model_id=f"{group_id}:{model_id}", ), internal_limit_reservation=internal_limit_reservation, group_id=group_id, model_id=model_id, pricing=credit_pricing, ) def settle(self, success_count: int) -> None: if self.settled: return if self.internal_limit_reservation is not None: self.internal_limit_reservation.settle(success_count) success_cost = _credit_amount(min(float(self.amount), max(0, int(success_count or 0)) * float(self.per_image_cost))) if self.mode == "dedicated_wallet" and self.user_id and self.amount > 0: if success_cost > 0: auth_service.consume_third_party_image_wallet( self.user_id, group_id=self.group_id, model_id=self.model_id, amount=success_cost, ) refund = self.amount - success_cost if refund > 0: auth_service.refund_third_party_image_wallet( self.user_id, group_id=self.group_id, model_id=self.model_id, amount=refund, ) elif self.credit_reservation is not None: self.credit_reservation.settle(success_cost) self.actual = success_cost self.refund = _credit_amount(float(self.amount) - float(success_cost)) if self.pricing: self.log_detail["billing_actual"] = self.actual self.log_detail["billing_refund"] = self.refund self.settled = True async def run_metered_image_call( call: LoggedCall, handler, payload: dict[str, object], identity: dict[str, object], *, requested_amount: int | None = None, ): try: reservation = ImageBillingReservation.reserve(identity, payload, requested_amount=requested_amount) except PermissionError as exc: raise HTTPException(status_code=403, detail={"error": str(exc)}) from exc except ValueError as exc: raise HTTPException(status_code=402, detail={"error": str(exc)}) from exc call.billing_detail = reservation.log_detail stream_success_count = 0 def on_stream_item(item: object) -> None: nonlocal stream_success_count stream_success_count += _count_successful_images(item) def on_stream_complete() -> None: reservation.settle(stream_success_count) def on_stream_error(_exc: BaseException) -> None: reservation.settle(stream_success_count) try: result = await call.run( handler, payload, on_stream_item=on_stream_item, on_stream_complete=on_stream_complete, on_stream_error=on_stream_error, on_result=lambda value: reservation.settle(_count_successful_images(value)), ) except Exception: reservation.settle(0) raise if isinstance(result, StreamingResponse): return result reservation.settle(_count_successful_images(result)) return result def _external_prompt_optimization(prompt: str) -> tuple[str, str]: base_url = config.prompt_optimizer_base_url.rstrip("/") model = config.prompt_optimizer_model if not base_url: raise ValueError("第三方提示词优化 Base URL 不能为空") endpoint = base_url if base_url.endswith("/chat/completions") else f"{base_url}/chat/completions" headers = {"Content-Type": "application/json"} if config.prompt_optimizer_api_key: headers["Authorization"] = f"Bearer {config.prompt_optimizer_api_key}" response = curl_requests.post( endpoint, headers=headers, json={ "model": model, "stream": False, "messages": [ {"role": "system", "content": config.prompt_optimizer_system_prompt}, { "role": "user", "content": "只优化下面的原始提示词，保持原语言并仅返回改写后的提示词：\n" + prompt, }, ], }, timeout=60, ) if response.status_code >= 400: raise RuntimeError(f"第三方提示词优化接口返回 HTTP {response.status_code}: {response.text[:500]}") data = response.json() text = _chat_completion_text(data) if isinstance(data, dict) else "" if not text: raise RuntimeError("第三方提示词优化接口未返回有效内容") return text, model def _external_reverse_prompt(image: str) -> tuple[str, str]: base_url = config.reverse_prompt_base_url.rstrip("/") model = config.reverse_prompt_model if not base_url: raise ValueError("第三方反推提示词 Base URL 不能为空") endpoint = base_url if base_url.endswith("/chat/completions") else f"{base_url}/chat/completions" headers = {"Content-Type": "application/json"} if config.reverse_prompt_api_key: headers["Authorization"] = f"Bearer {config.reverse_prompt_api_key}" instruction = config.reverse_prompt_system_prompt response = curl_requests.post( endpoint, headers=headers, json={ "model": model, "stream": False, "messages": [ {"role": "system", "content": instruction}, { "role": "user", "content": [ {"type": "text", "text": instruction}, {"type": "image_url", "image_url": {"url": image}}, ], }, ], }, timeout=120, ) if response.status_code >= 400: raise RuntimeError(f"第三方反推提示词接口返回 HTTP {response.status_code}: {response.text[:500]}") data = response.json() text = _chat_completion_text(data) if isinstance(data, dict) else "" if not text: raise RuntimeError("第三方反推提示词接口未返回有效内容") return text, model def collect_models_result(identity: dict[str, object]) -> dict[str, Any]: """上游账号池模型 + 第三方接入模型，合并且按 id 去重后的完整目录。 `/v1/models`（对外 OpenAI 兼容）与 `/api/chat/models`（对话页、 管理页的「对话可用模型」）必须用同一份目录，否则两边口径会不一致—— 之前 `/api/chat/models` 只取 `openai_v1_models.list_models()`， 漏掉了在这里额外拼接的第三方模型，导致第三方模型在对话候选里根本不出现。 """ result = openai_v1_models.list_models() data = result.get("data") if isinstance(result, dict) else None if not isinstance(data, list): return result seen = {str(item.get("id") or "").strip() for item in data if isinstance(item, dict)} for item in third_party_image_service.public_models_for_identity(identity): model_id = str(item.get("id") or "").strip() if not model_id or model_id in seen: continue data.append(item) seen.add(model_id) return result def create_router() -> APIRouter: router = APIRouter() @router.get("/v1/models") async def list_models(authorization: str | None = Header(default=None)): identity = require_identity(authorization) try: return await run_in_threadpool(collect_models_result, identity) except Exception as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc @router.get("/api/chat/models") async def list_chat_models(authorization: str | None = Header(default=None)): """对话页模型下拉 / 管理页「对话可用模型」的数据源。 `/v1/models` 是给外部 API 客户端用的 OpenAI 兼容接口，必须保持全量 （含第三方生图模型），所以这里另开一个接口：全量候选 + 每个模型的 `chat_enabled` 标记（自动规则叠加人工覆盖）。 候选包含第三方接入模型——它们默认隐藏（生图模型），但可以被手动开启； 将来第三方接入文本 / 多模态模型时，只要不带生图能力就会默认出现在对话下拉里。 """ identity = require_identity(authorization) try: result = await run_in_threadpool(collect_models_result, identity) except Exception as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc items = result.get("data") if isinstance(result, dict) else None overrides = config.chat_models data = resolve_chat_models(items if isinstance(items, list) else [], overrides) return { "object": "list", "data": data, "include": overrides["include"], "exclude": overrides["exclude"], } @router.get("/api/image/models") async def list_image_models(authorization: str | None = Header(default=None)): """生图页模型下拉 / 管理页「生图可用模型」的数据源。 只列出能生图的模型（账号池上游内置生图模型 + 第三方接入生图模型）， 每个带 `image_enabled` 标记。默认全部启用 —— 这里的开关只是展示层过滤， 不改动第三方生图配置（计费 / 路由 / 额度 / 对外 API 均不受影响）。 """ identity = require_identity(authorization) try: result = await run_in_threadpool(collect_models_result, identity) except Exception as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc items = result.get("data") if isinstance(result, dict) else None overrides = config.image_models data = resolve_image_models(items if isinstance(items, list) else [], overrides) return { "object": "list", "data": data, "include": overrides["include"], "exclude": overrides["exclude"], } @router.get("/api/system/models") async def list_system_models(authorization: str | None = Header(default=None)): """管理页「系统可用模型」的数据源。 与 `/v1/models` 同一份全量目录（上游账号池 + 第三方接入）， 额外带上 `system_enabled` 标记：管理员可以把不关心的模型从这张列表里收起来。 注意这**只是展示层过滤**：`/v1/models` 本身仍保持全量， 上游账号池、第三方配置、计费与路由都不受影响。 """ identity = require_identity(authorization) try: result = await run_in_threadpool(collect_models_result, identity) except Exception as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc items = result.get("data") if isinstance(result, dict) else None overrides = config.system_models data = resolve_system_models(items if isinstance(items, list) else [], overrides) return { "object": "list", "data": data, "include": overrides["include"], "exclude": overrides["exclude"], } @router.post("/v1/images/generations") async def generate_images( body: ImageGenerationRequest, request: Request, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) payload = body.model_dump(mode="python") payload["base_url"] = resolve_image_base_url(request) _attach_account_pool(payload, identity) call = LoggedCall(identity, "/v1/images/generations", body.model, "文生图", request_text=body.prompt) await filter_or_log(call, body.prompt) return await run_metered_image_call(call, openai_v1_image_generations.handle, payload, identity) @router.post("/v1/images/edits") async def edit_images( request: Request, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) payload, image_sources, mask_sources = await parse_image_edit_request(request) prompt = str(payload["prompt"]) model = str(payload["model"]) call = LoggedCall(identity, "/v1/images/edits", model, "图生图", request_text=prompt) await filter_or_log(call, prompt) payload["images"] = await read_image_sources(image_sources) if mask_sources: payload["mask"] = await read_image_sources(mask_sources) payload["base_url"] = resolve_image_base_url(request) _attach_account_pool(payload, identity) return await run_metered_image_call(call, openai_v1_image_edit.handle, payload, identity) @router.post("/v1/chat/completions") async def create_chat_completion( body: ChatCompletionRequest, request: Request, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) payload = body.model_dump(mode="python") model = str(payload.get("model") or "auto") request_preview = request_text(payload.get("prompt"), payload.get("messages")) is_image_request = is_image_chat_request(payload) payload["base_url"] = resolve_image_base_url(request) if is_image_request: _attach_account_pool(payload, identity) call = LoggedCall(identity, "/v1/chat/completions", model, "图片生成" if is_image_request else "文本生成", request_text=request_preview) if is_image_request: # AI review protects image accounts. Plain chat is also used by # internal Skill controllers and image planners; reviewing their # system protocols creates false positives and never protects an # image-account call because no image account is used here. await filter_or_log(call, request_preview) return await run_metered_image_call( call, openai_v1_chat_complete.handle, payload, identity, requested_amount=parse_image_count(payload.get("n")), ) return await call.run(openai_v1_chat_complete.handle, payload, identity) @router.post("/api/prompt/optimize") async def optimize_prompt( body: PromptOptimizationRequest, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) prompt = body.prompt.strip() if not prompt: raise HTTPException(status_code=400, detail={"error": "提示词不能为空"}) if config.prompt_optimizer_provider == "external": try: optimized_prompt, model = await run_in_threadpool(_external_prompt_optimization, prompt) except (ValueError, RuntimeError) as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc return {"prompt": optimized_prompt, "model": model} payload = { "model": config.prompt_optimizer_model, "stream": False, "messages": [ {"role": "system", "content": config.prompt_optimizer_system_prompt}, { "role": "user", "content": ( f"{config.prompt_optimizer_system_prompt}\n\n" "Improve only the original prompt below. Preserve its language exactly and return only the rewritten prompt.\n" f"\n{prompt}\n" ), }, ], } call = LoggedCall(identity, "/api/prompt/optimize", config.prompt_optimizer_model, "提示词优化", request_text=prompt) result = await call.run(openai_v1_chat_complete.handle, payload, identity) if not isinstance(result, dict): return result optimized_prompt = _chat_completion_text(result) if not optimized_prompt: raise HTTPException(status_code=502, detail={"error": "模型未返回优化后的提示词"}) return {"prompt": optimized_prompt, "model": config.prompt_optimizer_model} @router.post("/api/prompt/reverse") async def reverse_prompt( body: ReversePromptRequest, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) image = body.image.strip() header, separator, encoded = image.partition(",") if not separator or not header.startswith("data:image/") or ";base64" not in header or not encoded.strip(): raise HTTPException(status_code=400, detail={"error": "图片数据无效"}) if config.reverse_prompt_provider == "external": try: prompt, model = await run_in_threadpool(_external_reverse_prompt, image) except (ValueError, RuntimeError) as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc return {"prompt": prompt, "model": model} instruction = config.reverse_prompt_system_prompt model = config.reverse_prompt_model payload = { "model": model, "stream": False, "instructions": instruction, "input": [ {"type": "input_text", "text": instruction}, {"type": "input_image", "image_url": image}, ], } call = LoggedCall(identity, "/api/prompt/reverse", model, "反推提示词", request_text="参考图片") result = await call.run(openai_v1_response.handle, payload) if not isinstance(result, dict): return result prompt = _response_text(result) if not prompt: raise HTTPException(status_code=502, detail={"error": "模型未返回反推提示词"}) return {"prompt": prompt, "model": model} @router.post("/api/image-annotations/identify") async def identify_annotation_region( body: ImageRegionRecognitionRequest, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) try: return await run_in_threadpool( identify_image_region, identity, body.image, body.bounds.model_dump(mode="python"), ) except ValueError as exc: raise HTTPException(status_code=400, detail={"error": str(exc)}) from exc except RuntimeError as exc: raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc @router.post("/v1/responses") async def create_response( body: ResponseCreateRequest, request: Request, authorization: str | None = Header(default=None), ): identity = require_identity(authorization) payload = body.model_dump(mode="python") model = str(payload.get("model") or "auto") request_preview = request_text(payload.get("input"), payload.get("instructions")) is_image_request = has_response_image_generation_tool(payload) if is_image_request: payload["base_url"] = resolve_image_base_url(request) _attach_account_pool(payload, identity) call = LoggedCall(identity, "/v1/responses", model, "Responses 图片生成" if is_image_request else "Responses", request_text=request_preview) if is_image_request: await filter_or_log(call, request_preview) return await run_metered_image_call( call, openai_v1_response.handle, payload, identity, requested_amount=1, ) return await call.run(openai_v1_response.handle, payload) @router.post("/v1/messages") async def create_message( body: AnthropicMessageRequest, authorization: str | None = Header(default=None), x_api_key: str | None = Header(default=None, alias="x-api-key"), anthropic_version: str | None = Header(default=None, alias="anthropic-version"), ): identity = require_identity(authorization or (f"Bearer {x_api_key}" if x_api_key else None)) payload = body.model_dump(mode="python") model = str(payload.get("model") or "auto") request_preview = request_text(payload.get("system"), payload.get("messages"), payload.get("tools")) call = LoggedCall(identity, "/v1/messages", model, "Messages", request_text=request_preview) return await call.run(anthropic_v1_messages.handle, payload, sse="anthropic") @router.post("/v1/search") async def search(body: SearchRequest, authorization: str | None = Header(default=None)): identity = require_identity(authorization) call = LoggedCall(identity, "/v1/search", openai_search.MODEL, "搜索", request_text=body.prompt) return await call.run(openai_search.handle, body.model_dump(mode="python")) @router.get("/v1/editable-file-tasks") async def list_editable_file_tasks(ids: str = "", authorization: str | None = Header(default=None)): identity = require_identity(authorization) task_ids = [item.strip() for item in ids.split(",") if item.strip()] return await run_in_threadpool(editable_file_task_service.list_tasks, identity, task_ids) @router.get("/files/{file_path:path}") async def download_editable_file(file_path: str, download: bool = False): if file_path.startswith("skills/"): await run_in_threadpool(skill_service.cleanup_expired_runs) try: path = await run_in_threadpool(editable_file_task_service.public_file_path, file_path) except Exception as exc: raise HTTPException(status_code=404, detail={"error": "file not found"}) from exc media_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream" if path.suffix.lower() == ".svg": media_type = "image/svg+xml" if download: return FileResponse(path, media_type=media_type, filename=path.name, content_disposition_type="attachment") return FileResponse(path, media_type=media_type) @router.post("/v1/ppt/generations") async def create_ppt_task(body: EditableFileTaskRequest, request: Request, authorization: str | None = Header(default=None)): identity = require_identity(authorization) await filter_or_log(LoggedCall(identity, "/v1/ppt/generations", "gpt-5-5-thinking", "PPT生成任务", request_text=body.prompt), body.prompt) return await run_in_threadpool( editable_file_task_service.submit_ppt, identity, client_task_id=body.client_task_id or "", prompt=body.prompt, base64_images=body.base64_images, base_url=resolve_image_base_url(request), ) @router.post("/v1/psd/generations") async def create_psd_task(body: EditableFileTaskRequest, request: Request, authorization: str | None = Header(default=None)): identity = require_identity(authorization) await filter_or_log(LoggedCall(identity, "/v1/psd/generations", "gpt-5-5-thinking", "PSD生成任务", request_text=body.prompt), body.prompt) return await run_in_threadpool( editable_file_task_service.submit_psd, identity, client_task_id=body.client_task_id or "", prompt=body.prompt, base64_images=body.base64_images, base_url=resolve_image_base_url(request), ) return router