service-forge 0.1.11__py3-none-any.whl → 0.1.21__py3-none-any.whl

service_forge/api/http_api.py

@@ -8,6 +8,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.utils import get_openapi
 from service_forge.api.routers.websocket.websocket_router import websocket_router
 from service_forge.api.routers.service.service_router import service_router
+from service_forge.api.routers.feedback.feedback_router import router as feedback_router
 from service_forge.sft.config.sf_metadata import load_metadata
 from service_forge.sft.util.name_util import get_service_url_name
 
@@ -78,6 +79,9 @@ def create_app(
     
     # Always include WebSocket router
     app.include_router(websocket_router)
+
+    # Include Feedback router
+    app.include_router(feedback_router)
     
     # Always include Service router
     app.include_router(service_router)

service_forge/api/routers/feedback/feedback_router.py

@@ -0,0 +1,148 @@
+import os
+import httpx
+from fastapi import APIRouter, HTTPException, Query, BackgroundTasks
+from loguru import logger
+from typing import Optional
+
+from service_forge.model.feedback import FeedbackCreate, FeedbackResponse, FeedbackListResponse
+from service_forge.storage.feedback_storage import feedback_storage
+from service_forge.db.database import create_database_manager
+from service_forge.current_service import get_service
+
+router = APIRouter(prefix="/sdk/feedback", tags=["feedback"])
+
+def get_forward_api_url():
+    if not get_service():
+        return None
+    if not get_service().config.feedback:
+        return None
+    return get_service().config.feedback.api_url
+
+def get_forward_api_timeout():
+    if not get_service():
+        return None
+    if not get_service().config.feedback:
+        return None
+    return get_service().config.feedback.api_timeout
+
+async def forward_feedback_to_api(feedback_data: dict):
+    """
+    将反馈数据转发到外部 API
+
+    Args:
+        feedback_data: 反馈数据字典
+    """
+    forward_api_url = get_forward_api_url()
+    forward_api_timeout = get_forward_api_timeout()
+    print(forward_api_url)
+    print(forward_api_timeout)
+    if not forward_api_url:
+        logger.debug("未配置转发 API URL，跳过转发")
+        return
+    try:
+        # 处理 datetime 对象，转换为 ISO 格式字符串
+        serializable_data = feedback_data.copy()
+        if 'created_at' in serializable_data and serializable_data['created_at']:
+            serializable_data['created_at'] = serializable_data['created_at'].isoformat()
+
+        async with httpx.AsyncClient(timeout=forward_api_timeout) as client:
+            response = await client.post(
+                forward_api_url,
+                json=serializable_data,
+                headers={"Content-Type": "application/json"}
+            )
+            response.raise_for_status()
+            logger.info(f"反馈转发成功: feedback_id={feedback_data.get('feedback_id')}, status={response.status_code}")
+    except httpx.TimeoutException:
+        logger.warning(f"反馈转发超时: {forward_api_url}")
+    except httpx.ConnectError as e:
+        logger.warning(f"反馈转发连接失败: {forward_api_url} - {e}")
+    except httpx.HTTPStatusError as e:
+        logger.error(f"反馈转发失败: status={e.response.status_code}, detail={e.response.text}")
+    except Exception as e:
+        logger.error(f"反馈转发异常: {type(e).__name__}: {e}")
+
+
+
+@router.post("/", response_model=FeedbackResponse, summary="创建工作流反馈")
+async def create_feedback(feedback: FeedbackCreate, background_tasks: BackgroundTasks):
+    """
+    创建工作流执行完成后的用户反馈
+    - **task_id**: 工作流任务ID - workflow的id
+    - **workflow_name**: 工作流名称 - workflow的名称
+    - **rating**: 可选的评分 (1-5) - 反馈中的一种，评分，可以为空
+    - **comment**: 可选的用户评论 - 反馈中的一种，可以为空
+    - **metadata**: 可选的额外元数据
+    还少什么？ - trace_id?
+    """
+    try:
+        # 保存到数据库
+        feedback_data = await feedback_storage.create_feedback(
+            task_id=feedback.task_id,
+            workflow_name=feedback.workflow_name,
+            rating=feedback.rating,
+            comment=feedback.comment,
+            metadata=feedback.metadata,
+        )
+
+        # 后台任务转发到外部 API (不阻塞响应)
+        background_tasks.add_task(forward_feedback_to_api, feedback_data)
+
+        return FeedbackResponse(**feedback_data)
+    except Exception as e:
+        logger.error(f"创建反馈失败: {e}")
+        raise HTTPException(status_code=500, detail=f"创建反馈失败: {str(e)}")
+
+
+@router.get("/{feedback_id}", response_model=FeedbackResponse, summary="获取单个反馈")
+async def get_feedback(feedback_id: str):
+    """
+    根据反馈ID获取反馈详情
+
+    - **feedback_id**: 反馈ID
+    """
+    feedback = await feedback_storage.get_feedback(feedback_id)
+    if not feedback:
+        raise HTTPException(status_code=404, detail="反馈不存在")
+    return FeedbackResponse(**feedback)
+
+
+@router.get("/", response_model=FeedbackListResponse, summary="获取反馈列表")
+async def list_feedbacks(
+    task_id: Optional[str] = Query(None, description="按任务ID筛选"),
+    workflow_name: Optional[str] = Query(None, description="按工作流名称筛选"),
+):
+    """
+    获取反馈列表,支持按任务ID或工作流名称筛选
+
+    - **task_id**: 可选,按任务ID筛选
+    - **workflow_name**: 可选,按工作流名称筛选
+    """
+    try:
+        if task_id:
+            feedbacks = await feedback_storage.get_feedbacks_by_task(task_id)
+        elif workflow_name:
+            feedbacks = await feedback_storage.get_feedbacks_by_workflow(workflow_name)
+        else:
+            feedbacks = await feedback_storage.get_all_feedbacks()
+
+        return FeedbackListResponse(
+            total=len(feedbacks),
+            feedbacks=[FeedbackResponse(**f) for f in feedbacks]
+        )
+    except Exception as e:
+        logger.error(f"获取反馈列表失败: {e}")
+        raise HTTPException(status_code=500, detail=f"获取反馈列表失败: {str(e)}")
+
+
+@router.delete("/{feedback_id}", summary="删除反馈")
+async def delete_feedback(feedback_id: str):
+    """
+    删除指定的反馈
+
+    - **feedback_id**: 反馈ID
+    """
+    success = await feedback_storage.delete_feedback(feedback_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="反馈不存在")
+    return {"message": "反馈删除成功", "feedback_id": feedback_id}

service_forge/api/routers/service/service_router.py

@@ -1,24 +1,13 @@
+import os
+import uuid
+import tempfile
 from fastapi import APIRouter, HTTPException, UploadFile, File, Form
 from fastapi.responses import JSONResponse
 from loguru import logger
 from typing import Optional, TYPE_CHECKING
-import tempfile
-import os
 from pydantic import BaseModel
 from omegaconf import OmegaConf
-
-if TYPE_CHECKING:
-    from service_forge.service import Service
-
-# TODO: refactor this, do not use global variable
-_current_service: Optional['Service'] = None
-
-def set_service(service: 'Service') -> None:
-    global _current_service
-    _current_service = service
-
-def get_service() -> Optional['Service']:
-    return _current_service
+from service_forge.current_service import get_service
 
 service_router = APIRouter(prefix="/sdk/service", tags=["service"])
 
@@ -29,6 +18,7 @@ class WorkflowStatusResponse(BaseModel):
     workflows: list[dict]
 
 class WorkflowActionResponse(BaseModel):
+    workflow_id: str
     success: bool
     message: str
 
@@ -45,43 +35,42 @@ async def get_service_status():
         logger.error(f"Error getting service status: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@service_router.post("/workflow/{workflow_name}/start", response_model=WorkflowActionResponse)
-async def start_workflow(workflow_name: str):
+@service_router.post("/workflow/{workflow_id}/start", response_model=WorkflowActionResponse)
+async def start_workflow(workflow_id: str):
     service = get_service()
     if service is None:
         raise HTTPException(status_code=503, detail="Service not initialized")
     
     try:
-        success = await service.start_workflow(workflow_name)
+        success = service.start_workflow_by_id(uuid.UUID(workflow_id))
         if success:
-            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_name} started successfully")
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} started successfully")
         else:
-            return WorkflowActionResponse(success=False, message=f"Failed to start workflow {workflow_name}")
+            return WorkflowActionResponse(success=False, message=f"Failed to start workflow {workflow_id}")
     except Exception as e:
-        logger.error(f"Error starting workflow {workflow_name}: {e}")
+        logger.error(f"Error starting workflow {workflow_id}: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@service_router.post("/workflow/{workflow_name}/stop", response_model=WorkflowActionResponse)
-async def stop_workflow(workflow_name: str):
+@service_router.post("/workflow/{workflow_id}/stop", response_model=WorkflowActionResponse)
+async def stop_workflow(workflow_id: str):
     service = get_service()
     if service is None:
         raise HTTPException(status_code=503, detail="Service not initialized")
     
     try:
-        success = await service.stop_workflow(workflow_name)
+        success = await service.stop_workflow_by_id(uuid.UUID(workflow_id))
         if success:
-            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_name} stopped successfully")
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} stopped successfully")
         else:
-            return WorkflowActionResponse(success=False, message=f"Failed to stop workflow {workflow_name}")
+            return WorkflowActionResponse(success=False, message=f"Failed to stop workflow {workflow_id}")
     except Exception as e:
-        logger.error(f"Error stopping workflow {workflow_name}: {e}")
+        logger.error(f"Error stopping workflow {workflow_id}: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @service_router.post("/workflow/upload", response_model=WorkflowActionResponse)
 async def upload_workflow_config(
     file: Optional[UploadFile] = File(None),
     config_content: Optional[str] = Form(None),
-    workflow_name: Optional[str] = Form(None)
 ):
     service = get_service()
     if service is None:
@@ -104,18 +93,19 @@ async def upload_workflow_config(
                 content = await file.read()
                 temp_file.write(content)
                 temp_file_path = temp_file.name
-            
-            success = await service.load_workflow_from_config(config_path=temp_file_path, workflow_name=workflow_name)
+           
+            workflow_id = await service.load_workflow_from_config(config_path=temp_file_path)
         else:
             try:
                 config = OmegaConf.to_object(OmegaConf.create(config_content))
             except Exception as e:
                 raise HTTPException(status_code=400, detail=f"Invalid YAML format: {str(e)}")
             
-            success = await service.load_workflow_from_config(config=config, workflow_name=workflow_name)
+            workflow_id = await service.load_workflow_from_config(config=config)
         
-        if success:
+        if workflow_id:
             return WorkflowActionResponse(
+                workflow_id=str(workflow_id),
                 success=True,
                 message=f"Workflow configuration uploaded and loaded successfully"
             )

service_forge/current_service.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from service_forge.service import Service
+
+_current_service: Service | None = None
+
+def set_service(service: Service) -> None:
+    global _current_service
+    _current_service = service
+
+def get_service() -> Service | None:
+    return _current_service

service_forge/db/database.py

@@ -5,9 +5,8 @@ import pymongo
 import psycopg2
 from typing import AsyncGenerator
 from loguru import logger
-from omegaconf import OmegaConf
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy import text
+from service_forge.service_config import ServiceConfig
 
 class PostgresDatabase:
     def __init__(
@@ -188,50 +187,48 @@ class DatabaseManager:
         return None
 
     @staticmethod
-    def from_config(config_path: str = None, config = None) -> DatabaseManager:
+    def from_config(config_path: str = None, config: ServiceConfig = None) -> DatabaseManager:
         if config is None:
-            config = OmegaConf.to_object(OmegaConf.load(config_path))
+            config = ServiceConfig.from_yaml_file(config_path)
 
-        databases_config = config.get('databases', None)
         postgres_databases = []
         mongo_databases = []
         redis_databases = []
+
+        databases_config = config.databases
+
         if databases_config is not None:
             for database_config in databases_config:
-                if ('postgres_host' in database_config and database_config['postgres_host'] is not None) + \
-                    ('mongo_host' in database_config and database_config['mongo_host'] is not None) + \
-                    ('redis_host' in database_config and database_config['redis_host'] is not None) == 0:
-                    raise ValueError(f"Database '{database_config['name']}' is missing required configuration. Please check your service.yaml file.")
-
-                if ('postgres_host' in database_config and database_config['postgres_host'] is not None) + \
-                    ('mongo_host' in database_config and database_config['mongo_host'] is not None) + \
-                    ('redis_host' in database_config and database_config['redis_host'] is not None) > 1:
+                if all([database_config.postgres_host is None, database_config.mongo_host is None, database_config.redis_host is None]):
+                    raise ValueError(f"Database '{database_config.name}' is missing required configuration. Please check your service.yaml file.")
+
+                if (database_config.postgres_host is not None) + (database_config.mongo_host is not None) + (database_config.redis_host is not None) > 1:
                     raise ValueError(f"Database '{database_config['name']}' has multiple host configurations. Please check your service.yaml file.")
 
-                if 'postgres_host' in database_config and database_config['postgres_host'] is not None:
+                if database_config.postgres_host is not None:
                     postgres_databases.append(PostgresDatabase(
-                        name=database_config['name'],
-                        postgres_user=database_config['postgres_user'],
-                        postgres_password=database_config['postgres_password'],
-                        postgres_host=database_config['postgres_host'],
-                        postgres_port=database_config['postgres_port'],
-                        postgres_db=database_config['postgres_db'],
+                        name=database_config.name,
+                        postgres_user=database_config.postgres_user,
+                        postgres_password=database_config.postgres_password,
+                        postgres_host=database_config.postgres_host,
+                        postgres_port=database_config.postgres_port,
+                        postgres_db=database_config.postgres_db,
                     ))
-                if 'mongo_host' in database_config and database_config['mongo_host'] is not None:
+                elif database_config.mongo_host is not None:
                     mongo_databases.append(MongoDatabase(
-                        name=database_config['name'],
-                        mongo_host=database_config['mongo_host'],
-                        mongo_port=database_config['mongo_port'],
-                        mongo_user=database_config['mongo_user'],
-                        mongo_password=database_config['mongo_password'],
-                        mongo_db=database_config['mongo_db'],
+                        name=database_config.name,
+                        mongo_host=database_config.mongo_host,
+                        mongo_port=database_config.mongo_port,
+                        mongo_user=database_config.mongo_user,
+                        mongo_password=database_config.mongo_password,
+                        mongo_db=database_config.mongo_db,
                     ))
-                if 'redis_host' in database_config and database_config['redis_host'] is not None:
+                elif database_config.redis_host is not None:
                     redis_databases.append(RedisDatabase(
-                        name=database_config['name'],
-                        redis_host=database_config['redis_host'],
-                        redis_port=database_config['redis_port'],
-                        redis_password=database_config['redis_password'],
+                        name=database_config.name,
+                        redis_host=database_config.redis_host,
+                        redis_port=database_config.redis_port,
+                        redis_password=database_config.redis_password,
                     ))
 
         return DatabaseManager(postgres_databases=postgres_databases, mongo_databases=mongo_databases, redis_databases=redis_databases)

service_forge/db/migrations/feedback_migration.py

@@ -0,0 +1,154 @@
+"""
+数据库迁移脚本 - 创建 feedback 表
+
+使用方法:
+1. 确保你的 service.yaml 中配置了数据库连接
+2. 运行此脚本: python -m src.service_forge.db.migrations.feedback_migration
+
+此脚本会:
+- 检查 feedback 表是否存在
+- 如果不存在,创建 feedback 表及索引
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# 添加项目根目录到 Python 路径
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from loguru import logger
+from sqlalchemy import text
+from src.service_forge.db.database import DatabaseManager
+from src.service_forge.db.models.feedback import Base, FeedbackBase
+
+
+async def create_database_if_not_exists(db):
+    """如果数据库不存在，则创建数据库"""
+    from sqlalchemy import create_engine
+    from sqlalchemy.exc import OperationalError
+    import asyncpg
+
+    try:
+        # 先尝试连接目标数据库
+        await db.init()
+        logger.info(f"✓ 数据库 '{db.postgres_db}' 已存在")
+        await db.close()
+        return True
+    except Exception as e:
+        logger.info(f"数据库 '{db.postgres_db}' 不存在，准备创建...")
+
+        try:
+            # 连接到 postgres 默认数据库
+            conn = await asyncpg.connect(
+                host=db.postgres_host,
+                port=db.postgres_port,
+                user=db.postgres_user,
+                password=db.postgres_password,
+                database='postgres'
+            )
+
+            # 创建数据库
+            await conn.execute(f'CREATE DATABASE {db.postgres_db}')
+            await conn.close()
+
+            logger.info(f"✓ 数据库 '{db.postgres_db}' 创建成功!")
+            return True
+
+        except Exception as create_error:
+            logger.error(f"创建数据库失败: {create_error}")
+            return False
+
+
+async def create_feedback_table(database_manager: DatabaseManager):
+    """创建 feedback 表"""
+    db = database_manager.get_default_postgres_database()
+
+    if db is None:
+        logger.error("未找到默认 PostgreSQL 数据库配置")
+        return False
+
+    try:
+        # 1. 先确保数据库存在
+        db_created = await create_database_if_not_exists(db)
+        if not db_created:
+            return False
+
+        # 2. 连接到数据库
+        await db.init()
+        engine = db.engine
+
+        logger.info(f"连接到数据库: {db.database_url}")
+
+        # 3. 检查表是否存在
+        async with engine.begin() as conn:
+            result = await conn.execute(
+                text(
+                    "SELECT EXISTS (SELECT FROM information_schema.tables "
+                    "WHERE table_schema = 'public' AND table_name = 'feedback');"
+                )
+            )
+            table_exists = result.scalar()
+
+            if table_exists:
+                logger.info("✓ feedback 表已存在,跳过创建")
+                return True
+
+            logger.info("创建 feedback 表...")
+
+            # 4. 创建表
+            await conn.run_sync(Base.metadata.create_all)
+
+            logger.info("✓ feedback 表创建成功!")
+            logger.info("表结构:")
+            logger.info("  - feedback_id: UUID (主键)")
+            logger.info("  - task_id: VARCHAR(255) (索引)")
+            logger.info("  - workflow_name: VARCHAR(255) (索引)")
+            logger.info("  - rating: INTEGER (可选, 1-5)")
+            logger.info("  - comment: TEXT (可选)")
+            logger.info("  - metadata: JSONB (可选)")
+            logger.info("  - created_at: TIMESTAMP (索引)")
+            logger.info("  - updated_at: TIMESTAMP (可选)")
+
+        await db.close()
+        return True
+
+    except Exception as e:
+        logger.error(f"创建 feedback 表失败: {e}")
+        return False
+
+
+async def main():
+    """主函数"""
+    logger.info("=== Feedback 表迁移脚本 ===")
+
+    # 提示用户提供配置文件路径
+    if len(sys.argv) > 1:
+        config_path = sys.argv[1]
+    else:
+        logger.info("请提供 service 配置文件路径:")
+        logger.info("  python -m src.service_forge.db.migrations.feedback_migration <config_path>")
+        logger.info("例如:")
+        logger.info("  python -m src.service_forge.db.migrations.feedback_migration configs/service/my_service.yaml")
+        return
+
+    logger.info(f"读取配置文件: {config_path}")
+
+    try:
+        database_manager = DatabaseManager.from_config(config_path=config_path)
+        success = await create_feedback_table(database_manager)
+
+        if success:
+            logger.info("✓ 迁移完成!")
+        else:
+            logger.error("✗ 迁移失败")
+            sys.exit(1)
+
+    except Exception as e:
+        logger.error(f"迁移过程出错: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

service_forge/db/models/feedback.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from sqlalchemy import Column, String, Integer, DateTime, Text
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+from sqlalchemy.ext.declarative import declarative_base
+import uuid
+
+Base = declarative_base()
+
+
+class FeedbackBase(Base):
+    """反馈数据表模型"""
+    __tablename__ = "feedback"
+
+    feedback_id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    task_id = Column(String(255), nullable=False, index=True)
+    workflow_name = Column(String(255), nullable=False, index=True)
+    rating = Column(Integer, nullable=True)
+    comment = Column(Text, nullable=True)
+    extra_metadata = Column("metadata", JSONB, nullable=True, default={})
+    created_at = Column(DateTime, nullable=False, default=datetime.now, index=True)
+    updated_at = Column(DateTime, nullable=True, onupdate=datetime.now)
+
+    def to_dict(self):
+        """转换为字典格式"""
+        return {
+            "feedback_id": str(self.feedback_id),
+            "task_id": self.task_id,
+            "workflow_name": self.workflow_name,
+            "rating": self.rating,
+            "comment": self.comment,
+            "metadata": self.extra_metadata or {},
+            "created_at": self.created_at,
+        }

service_forge/llm/__init__.py

@@ -15,6 +15,7 @@ class Model(Enum):
     DOUBO_SEED_1_6_FLASH_250615 = "doubao-seed-1-6-flash-250615"
     DEEPSEEK_V3_250324 = "deepseek-v3-250324"
     AZURE_GPT_4O_MINI = "azure-gpt-4o-mini"
+    GEMINI = "gemini-2.5-flash"
 
     def provider(self) -> str:
         if self.value.startswith("gpt"):
@@ -27,6 +28,8 @@ class Model(Enum):
             return "deepseek"
         elif self.value.startswith("azure"):
             return "azure"
+        elif self.value.startswith("gemini"):
+            return "gemini"
         raise ValueError(f"Invalid model: {self.value}")
 
 def get_model(model: str) -> Model:
@@ -51,6 +54,8 @@ def get_llm(provider: str) -> LLM:
             _llm_dicts[provider] = LLM(os.environ.get("DEEPSEEK_API_KEY", ""), os.environ.get("DEEPSEEK_BASE_URL", ""), int(os.environ.get("DEEPSEEK_TIMEOUT", 2000)))
         elif provider == "azure":
             _llm_dicts[provider] = LLM(os.environ.get("AZURE_API_KEY", ""), os.environ.get("AZURE_BASE_URL", ""), int(os.environ.get("AZURE_TIMEOUT", 2000)), os.environ.get("AZURE_API_VERSION", ""))
+        elif provider == "gemini":
+            _llm_dicts[provider] = LLM(os.environ.get("GEMINI_API_KEY", ""), os.environ.get("GEMINI_BASE_URL", ""), int(os.environ.get("GEMINI_TIMEOUT", 2000)))
         else:
             raise ValueError(f"Invalid provider: {provider}")
     return _llm_dicts[provider]

service_forge/model/feedback.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Any
+from datetime import datetime
+from uuid import UUID
+
+
+class FeedbackCreate(BaseModel):
+    """创建反馈的请求模型"""
+    task_id: str = Field(..., description="工作流任务ID")
+    workflow_name: str = Field(..., description="工作流名称")
+    rating: Optional[int] = Field(None, ge=1, le=5, description="评分 (1-5)")
+    comment: Optional[str] = Field(None, description="用户评论")
+    metadata: Optional[dict[str, Any]] = Field(default_factory=dict, description="额外的元数据")
+
+
+class FeedbackResponse(BaseModel):
+    """反馈响应模型"""
+    feedback_id: str = Field(..., description="反馈ID")
+    task_id: str = Field(..., description="工作流任务ID")
+    workflow_name: str = Field(..., description="工作流名称")
+    rating: Optional[int] = Field(None, description="评分")
+    comment: Optional[str] = Field(None, description="用户评论")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="元数据")
+    created_at: datetime = Field(..., description="创建时间")
+
+
+class FeedbackListResponse(BaseModel):
+    """反馈列表响应模型"""
+    total: int = Field(..., description="总数")
+    feedbacks: list[FeedbackResponse] = Field(..., description="反馈列表")