| from __future__ import annotations |
|
|
| import json |
| from typing import Any |
|
|
| from fastapi import APIRouter, Header, HTTPException, Request |
| from fastapi.concurrency import run_in_threadpool |
| from pydantic import BaseModel, Field, ValidationError |
| from starlette.datastructures import UploadFile |
|
|
| from api.support import require_admin, require_identity |
| from services.image_api_adapter import ( |
| ADAPTER_MODEL, |
| adapter_system_prompt, |
| adapter_user_prompt, |
| document_to_text, |
| infer_document_auth_type, |
| normalize_adapter_result, |
| parse_model_json, |
| redact_document_secrets, |
| ) |
| from services.log_service import LoggedCall |
| from services.protocol import openai_v1_chat_complete |
| from services.third_party_image_service import third_party_image_service |
|
|
|
|
| class ThirdPartyImageGroupsRequest(BaseModel): |
| groups: list[dict[str, Any]] = Field(default_factory=list) |
| settings: dict[str, Any] | None = None |
|
|
|
|
| class ThirdPartyImageTestRequest(BaseModel): |
| connection_id: str = "" |
| connection: dict[str, Any] | None = None |
|
|
|
|
| class ThirdPartyImageAdaptDocumentRequest(BaseModel): |
| document: str = Field(..., min_length=1, max_length=650_000) |
| filename: str = Field(default="", max_length=300) |
| base_url: str = Field(default="", max_length=2000) |
|
|
|
|
| class ThirdPartyImageOnlineCallRequest(BaseModel): |
| connection: dict[str, Any] | None = None |
| adapter_template: dict[str, Any] | None = None |
| request_body: dict[str, Any] = Field(default_factory=dict) |
| operation: str = "generate" |
| call_mode: str = "custom" |
|
|
|
|
| class ThirdPartyImageOnlineModelsRequest(BaseModel): |
| connection: dict[str, Any] | None = None |
| adapter_template: dict[str, Any] | None = None |
|
|
|
|
| MAX_ONLINE_CALL_IMAGES = 8 |
| MAX_ONLINE_CALL_IMAGE_BYTES = 50 * 1024 * 1024 |
|
|
|
|
| def _json_object_field(form: Any, name: str, required: bool = False): |
| raw = form.get(name) |
| if raw in (None, "") and not required: |
| return None |
| if not isinstance(raw, str): |
| raise HTTPException(status_code=400, detail={"error": f"{name} 必须是 JSON 对象"}) |
| try: |
| value = json.loads(raw) |
| except json.JSONDecodeError as exc: |
| raise HTTPException(status_code=400, detail={"error": f"{name} 不是有效的 JSON"}) from exc |
| if not isinstance(value, dict): |
| raise HTTPException(status_code=400, detail={"error": f"{name} 必须是 JSON 对象"}) |
| return value |
|
|
|
|
| async def _parse_online_call_request( |
| request: Request, |
| ) -> tuple[ThirdPartyImageOnlineCallRequest, list[tuple[bytes, str, str]]]: |
| content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() |
| if content_type != "multipart/form-data": |
| try: |
| return ThirdPartyImageOnlineCallRequest.model_validate(await request.json()), [] |
| except (json.JSONDecodeError, ValidationError, TypeError) as exc: |
| raise HTTPException(status_code=400, detail={"error": "在线调用参数格式无效"}) from exc |
|
|
| form = await request.form() |
| body = ThirdPartyImageOnlineCallRequest( |
| connection=_json_object_field(form, "connection"), |
| adapter_template=_json_object_field(form, "adapter_template"), |
| request_body=_json_object_field(form, "request_body", required=True) or {}, |
| operation=str(form.get("operation") or "generate"), |
| call_mode=str(form.get("call_mode") or "custom"), |
| ) |
| uploads = [value for key, value in form.multi_items() if key == "images" and isinstance(value, UploadFile)] |
| if len(uploads) > MAX_ONLINE_CALL_IMAGES: |
| raise HTTPException(status_code=400, detail={"error": "参考图最多上传 8 张"}) |
|
|
| images: list[tuple[bytes, str, str]] = [] |
| total_bytes = 0 |
| for index, upload in enumerate(uploads): |
| mime_type = str(upload.content_type or "application/octet-stream").lower() |
| if not mime_type.startswith("image/"): |
| raise HTTPException(status_code=400, detail={"error": f"{upload.filename or '参考图'} 不是图片文件"}) |
| data = await upload.read(MAX_ONLINE_CALL_IMAGE_BYTES + 1) |
| total_bytes += len(data) |
| if not data: |
| raise HTTPException(status_code=400, detail={"error": f"{upload.filename or '参考图'} 内容为空"}) |
| if len(data) > MAX_ONLINE_CALL_IMAGE_BYTES or total_bytes > MAX_ONLINE_CALL_IMAGE_BYTES: |
| raise HTTPException(status_code=400, detail={"error": "参考图总大小不能超过 50 MB"}) |
| images.append((data, upload.filename or f"reference_{index + 1}.png", mime_type)) |
| return body, images |
|
|
|
|
| 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 create_router() -> APIRouter: |
| router = APIRouter() |
|
|
| @router.get("/api/third-party-images/groups") |
| async def list_groups(authorization: str | None = Header(default=None)): |
| require_admin(authorization) |
| return { |
| "groups": third_party_image_service.list_groups(), |
| "settings": third_party_image_service.get_settings(), |
| } |
|
|
| @router.post("/api/third-party-images/groups") |
| async def save_groups(body: ThirdPartyImageGroupsRequest, authorization: str | None = Header(default=None)): |
| require_admin(authorization) |
| try: |
| groups = await run_in_threadpool(third_party_image_service.save_groups, body.groups, body.settings) |
| return {"groups": groups, "settings": third_party_image_service.get_settings()} |
| except ValueError as exc: |
| raise HTTPException(status_code=400, detail={"error": str(exc)}) from exc |
|
|
| @router.post("/api/third-party-images/adapt-document") |
| async def adapt_document( |
| body: ThirdPartyImageAdaptDocumentRequest, |
| authorization: str | None = Header(default=None), |
| ): |
| identity = require_admin(authorization) |
| try: |
| readable = document_to_text(body.document, body.filename) |
| redacted = redact_document_secrets(readable) |
| except ValueError as exc: |
| raise HTTPException(status_code=400, detail={"error": str(exc)}) from exc |
| auth_hint = infer_document_auth_type(readable) |
| system_prompt = adapter_system_prompt() |
| user_prompt = adapter_user_prompt( |
| redacted, |
| filename=body.filename, |
| base_url=body.base_url, |
| auth_hint=auth_hint, |
| ) |
| payload = { |
| "model": ADAPTER_MODEL, |
| "stream": False, |
| "messages": [ |
| {"role": "system", "content": system_prompt}, |
| {"role": "user", "content": user_prompt}, |
| ], |
| } |
| call = LoggedCall( |
| identity, |
| "/api/third-party-images/adapt-document", |
| ADAPTER_MODEL, |
| "生图 API 文档适配", |
| request_text=f"导入文档：{body.filename or '未命名文档'}", |
| ) |
| result = await call.run(openai_v1_chat_complete.handle, payload) |
| model_text = _chat_completion_text(result) |
| if not model_text: |
| raise HTTPException(status_code=502, detail={"error": "站内 AI 未返回调用模板"}) |
| try: |
| normalized = normalize_adapter_result( |
| parse_model_json(model_text), |
| base_url=body.base_url, |
| auth_hint=auth_hint, |
| ) |
| except ValueError as exc: |
| raise HTTPException(status_code=502, detail={"error": f"AI 生成的调用模板未通过安全校验：{exc}"}) from exc |
| return { |
| **normalized, |
| "model": ADAPTER_MODEL, |
| "document_redacted": redacted != readable, |
| "auth_hint": auth_hint, |
| } |
|
|
| @router.post("/api/third-party-images/groups/{group_id}/connections/{connection_id}/online-call") |
| async def online_call_adapter( |
| group_id: str, |
| connection_id: str, |
| request: Request, |
| authorization: str | None = Header(default=None), |
| ): |
| require_admin(authorization) |
| body, reference_images = await _parse_online_call_request(request) |
| try: |
| if body.call_mode == "openai": |
| return await run_in_threadpool( |
| third_party_image_service.online_test_openai, |
| group_id, |
| connection_id, |
| connection_override=body.connection, |
| request_body=body.request_body, |
| reference_images=reference_images, |
| operation=body.operation, |
| ) |
| return await run_in_threadpool( |
| third_party_image_service.online_test_adapter, |
| group_id, |
| connection_id, |
| connection_override=body.connection, |
| adapter_template=body.adapter_template, |
| request_body=body.request_body, |
| reference_images=reference_images, |
| operation=body.operation, |
| ) |
| except ValueError as exc: |
| raise HTTPException(status_code=400, detail={"error": str(exc)}) from exc |
|
|
| @router.post("/api/third-party-images/groups/{group_id}/connections/{connection_id}/adapter-models") |
| async def online_adapter_models( |
| group_id: str, |
| connection_id: str, |
| body: ThirdPartyImageOnlineModelsRequest, |
| authorization: str | None = Header(default=None), |
| ): |
| require_admin(authorization) |
| try: |
| return await run_in_threadpool( |
| third_party_image_service.online_adapter_models, |
| group_id, |
| connection_id, |
| connection_override=body.connection, |
| adapter_template=body.adapter_template, |
| ) |
| except ValueError as exc: |
| raise HTTPException(status_code=400, detail={"error": str(exc)}) from exc |
| except Exception as exc: |
| raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc |
|
|
| @router.post("/api/third-party-images/groups/{group_id}/sync-models") |
| async def sync_models(group_id: str, authorization: str | None = Header(default=None)): |
| require_admin(authorization) |
| try: |
| return await run_in_threadpool(third_party_image_service.sync_models, group_id) |
| except ValueError as exc: |
| raise HTTPException(status_code=404, detail={"error": str(exc)}) from exc |
| except Exception as exc: |
| raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc |
|
|
| @router.post("/api/third-party-images/groups/{group_id}/connections/{connection_id}/sync-models") |
| async def sync_connection_models( |
| group_id: str, |
| connection_id: str, |
| body: ThirdPartyImageTestRequest, |
| authorization: str | None = Header(default=None), |
| ): |
| require_admin(authorization) |
| try: |
| return await run_in_threadpool( |
| third_party_image_service.sync_connection_models, |
| group_id, |
| connection_id, |
| body.connection, |
| ) |
| except ValueError as exc: |
| raise HTTPException(status_code=404, detail={"error": str(exc)}) from exc |
| except Exception as exc: |
| raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc |
|
|
| @router.post("/api/third-party-images/groups/{group_id}/test") |
| async def test_connection( |
| group_id: str, |
| body: ThirdPartyImageTestRequest, |
| authorization: str | None = Header(default=None), |
| ): |
| require_admin(authorization) |
| try: |
| return { |
| "result": await run_in_threadpool( |
| third_party_image_service.test_connection, |
| group_id, |
| body.connection_id, |
| body.connection, |
| ) |
| } |
| except ValueError as exc: |
| raise HTTPException(status_code=404, detail={"error": str(exc)}) from exc |
|
|
| @router.get("/api/third-party-images/options") |
| async def list_user_options(authorization: str | None = Header(default=None)): |
| identity = require_identity(authorization) |
| |
| |
| |
| return { |
| "models": third_party_image_service.public_models_for_identity(identity, image_only=True) |
| } |
|
|
| return router |
|
|
