diff --git a/packages/global/core/evaluation/api.d.ts b/packages/global/core/evaluation/api.d.ts
index 07cb6822c188..e15509ef2699 100644
--- a/packages/global/core/evaluation/api.d.ts
+++ b/packages/global/core/evaluation/api.d.ts
@@ -5,7 +5,8 @@ import type {
   EvaluationItemSchemaType,
   EvaluationDisplayType,
   EvaluationItemDisplayType,
-  EvaluationDataItemType
+  EvaluationDataItemType,
+  EvaluationStatistics
 } from './type';
 
 // ===== Common Types =====
@@ -51,7 +52,6 @@ export type EvaluationStatsResponse = {
   evaluating: number;
   queuing: number;
   error: number;
-  avgScore?: number;
 };
 
 // Export Evaluation Items
@@ -112,12 +112,7 @@ export type DataItemGroupedItem = {
   dataItemId: string;
   dataItem: EvaluationDataItemType;
   items: EvaluationItemDisplayType[];
-  summary: {
-    totalItems: number;
-    completedItems: number;
-    errorItems: number;
-    avgScore?: number;
-  };
+  statistics?: EvaluationStatistics;
 };
 export type DataItemListResponse = PaginationResponse<DataItemGroupedItem>;
 
diff --git a/packages/global/core/evaluation/type.d.ts b/packages/global/core/evaluation/type.d.ts
index f70c6175f052..6c54bb85d985 100644
--- a/packages/global/core/evaluation/type.d.ts
+++ b/packages/global/core/evaluation/type.d.ts
@@ -143,7 +143,6 @@ export type EvaluationDisplayType = Pick<
   | 'statistics'
 > & {
   _id: string;
-  avgScore?: number;
   datasetName?: string;
   target: EvalTarget; // Complete target object with extended config
   metricNames: string[];
@@ -161,6 +160,7 @@ export interface CreateEvaluationParams {
   datasetId: string;
   target: EvalTarget; // Only supports workflow type target configuration
   evaluators: EvaluatorSchema[]; // Replace metricIds with evaluators
+  autoStart?: boolean; // Whether to automatically start the evaluation task after creation (default: true)
 }
 
 // Queue job data types
diff --git a/packages/service/core/evaluation/task/index.ts b/packages/service/core/evaluation/task/index.ts
index 08e8b53773f4..15577e724cde 100644
--- a/packages/service/core/evaluation/task/index.ts
+++ b/packages/service/core/evaluation/task/index.ts
@@ -8,6 +8,7 @@ import type {
   EvaluationDataItemType,
   EvaluationDisplayType
 } from '@fastgpt/global/core/evaluation/type';
+import type { DataItemListResponse } from '@fastgpt/global/core/evaluation/api';
 import type { MetricResult } from '@fastgpt/global/core/evaluation/metric/type';
 import { Types } from 'mongoose';
 import { EvaluationStatusEnum } from '@fastgpt/global/core/evaluation/constants';
@@ -28,83 +29,6 @@ import { type ClientSession } from '../../../common/mongo';
 // Constants
 const MAX_EXPORT_PAGE_SIZE = 100000;
 
-// ===== Service Layer Response Types =====
-
-// List response type for evaluations
-export interface EvaluationListResponse {
-  list: EvaluationDisplayType[];
-  total: number;
-}
-
-// List response type for evaluation items
-export interface EvaluationItemListResponse {
-  items: EvaluationItemDisplayType[];
-  total: number;
-}
-
-// Statistics response for evaluation task
-export interface EvaluationStatsResponse {
-  total: number;
-  completed: number;
-  evaluating: number;
-  queuing: number;
-  error: number;
-  avgScore?: number;
-}
-
-// Result response for individual evaluation item
-export interface EvaluationItemResultResponse {
-  item: EvaluationItemSchemaType;
-  dataItem: EvaluationDataItemType;
-  response?: string;
-  result?: MetricResult;
-  score?: number;
-}
-
-// Export response for evaluation results
-export interface EvaluationExportResponse {
-  results: Buffer;
-  total: number;
-}
-
-// Export response for grouped data items
-export interface EvaluationExportByDataItemResponse {
-  results: Buffer;
-  totalItems: number;
-}
-
-// Grouped data item response
-export interface DataItemGroupedResponse {
-  list: DataItemGroupedType[];
-  total: number;
-}
-
-// Individual grouped data item type
-export interface DataItemGroupedType {
-  dataItemId: string;
-  dataItem: EvaluationDataItemType;
-  items: EvaluationItemDisplayType[];
-  summary: {
-    totalItems: number;
-    completedItems: number;
-    errorItems: number;
-    avgScore?: number;
-  };
-}
-
-// Batch operation response types
-export interface BatchDeleteResponse {
-  deletedCount: number;
-}
-
-export interface BatchRetryResponse {
-  retriedCount: number;
-}
-
-export interface BatchUpdateResponse {
-  updatedCount: number;
-}
-
 export class EvaluationTaskService {
   static async createEvaluation(
     params: CreateEvaluationParams & {
@@ -112,7 +36,7 @@ export class EvaluationTaskService {
       tmbId: string;
     }
   ): Promise<EvaluationSchemaType> {
-    const { teamId, tmbId, ...evaluationParams } = params;
+    const { teamId, tmbId, autoStart = true, ...evaluationParams } = params;
 
     // Create usage record
     const { billId } = await createEvaluationUsage({
@@ -124,17 +48,50 @@ export class EvaluationTaskService {
     // Apply default configuration to evaluators (weights, thresholds, etc.)
     const evaluatorsWithDefaultConfig = buildEvalDataConfig(evaluationParams.evaluators);
 
-    const evaluation = await MongoEvaluation.create({
-      ...evaluationParams,
-      evaluators: evaluatorsWithDefaultConfig,
-      teamId,
-      tmbId,
-      usageId: billId,
-      status: EvaluationStatusEnum.queuing,
-      createTime: new Date()
-    });
+    const createAndStart = async (session: ClientSession) => {
+      // Create evaluation within transaction
+      const evaluation = await MongoEvaluation.create(
+        [
+          {
+            ...evaluationParams,
+            evaluators: evaluatorsWithDefaultConfig,
+            teamId,
+            tmbId,
+            usageId: billId,
+            status: EvaluationStatusEnum.queuing,
+            createTime: new Date()
+          }
+        ],
+        { session }
+      );
 
-    return evaluation.toObject();
+      const evaluationObject = evaluation[0].toObject();
+
+      // Auto-start the evaluation if autoStart is true
+      if (autoStart) {
+        // Update status to evaluating within transaction
+        await MongoEvaluation.updateOne(
+          { _id: evaluationObject._id },
+          { $set: { status: EvaluationStatusEnum.evaluating } },
+          { session }
+        );
+
+        // Queue operation within transaction - if it fails, transaction will rollback
+        await evaluationTaskQueue.add(`eval_task_${evaluationObject._id}`, {
+          evalId: evaluationObject._id.toString()
+        });
+
+        // Update status in returned object
+        evaluationObject.status = EvaluationStatusEnum.evaluating;
+        addLog.debug(`[Evaluation] Task created and auto-started: ${evaluationObject._id}`);
+      } else {
+        addLog.debug(`[Evaluation] Task created: ${evaluationObject._id}`);
+      }
+
+      return evaluationObject;
+    };
+
+    return await mongoSessionRun(createAndStart);
   }
 
   static async getEvaluation(evalId: string, teamId: string): Promise<EvaluationSchemaType> {
@@ -213,7 +170,7 @@ export class EvaluationTaskService {
     accessibleIds?: string[],
     tmbId?: string,
     isOwner: boolean = false
-  ): Promise<EvaluationListResponse> {
+  ): Promise<{ list: EvaluationDisplayType[]; total: number }> {
     // Build basic filter and pagination
     const filter: any = { teamId: new Types.ObjectId(teamId) };
     if (searchKey) {
@@ -275,6 +232,29 @@ export class EvaluationTaskService {
             as: 'appVersion'
           }
         },
+        // Add real-time statistics lookup
+        {
+          $lookup: {
+            from: 'eval_items',
+            localField: '_id',
+            foreignField: 'evalId',
+            pipeline: [
+              {
+                $group: {
+                  _id: null,
+                  totalItems: { $sum: 1 },
+                  completedItems: {
+                    $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.completed] }, 1, 0] }
+                  },
+                  errorItems: {
+                    $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.error] }, 1, 0] }
+                  }
+                }
+              }
+            ],
+            as: 'realTimeStats'
+          }
+        },
         {
           $addFields: {
             datasetName: { $arrayElemAt: ['$dataset.name', 0] },
@@ -288,6 +268,23 @@ export class EvaluationTaskService {
                 as: 'evaluator',
                 in: '$$evaluator.metric.name'
               }
+            },
+            // Use real-time statistics if available, otherwise fallback to stored statistics
+            statistics: {
+              $cond: {
+                if: { $gt: [{ $size: '$realTimeStats' }, 0] },
+                then: {
+                  $let: {
+                    vars: { stats: { $arrayElemAt: ['$realTimeStats', 0] } },
+                    in: {
+                      totalItems: '$$stats.totalItems',
+                      completedItems: '$$stats.completedItems',
+                      errorItems: '$$stats.errorItems'
+                    }
+                  }
+                },
+                else: '$statistics'
+              }
             }
           }
         },
@@ -299,7 +296,6 @@ export class EvaluationTaskService {
             finishTime: 1,
             status: 1,
             errorMessage: 1,
-            avgScore: 1,
             datasetName: 1,
             target: {
               type: '$target.type',
@@ -359,11 +355,51 @@ export class EvaluationTaskService {
           as: 'appVersion'
         }
       },
+      // Add real-time statistics lookup
+      {
+        $lookup: {
+          from: 'eval_items',
+          localField: '_id',
+          foreignField: 'evalId',
+          pipeline: [
+            {
+              $group: {
+                _id: null,
+                totalItems: { $sum: 1 },
+                completedItems: {
+                  $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.completed] }, 1, 0] }
+                },
+                errorItems: {
+                  $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.error] }, 1, 0] }
+                }
+              }
+            }
+          ],
+          as: 'realTimeStats'
+        }
+      },
       {
         $addFields: {
           'target.config.appName': { $arrayElemAt: ['$app.name', 0] },
           'target.config.avatar': { $arrayElemAt: ['$app.avatar', 0] },
-          'target.config.versionName': { $arrayElemAt: ['$appVersion.versionName', 0] }
+          'target.config.versionName': { $arrayElemAt: ['$appVersion.versionName', 0] },
+          // Use real-time statistics if available, otherwise fallback to stored statistics
+          statistics: {
+            $cond: {
+              if: { $gt: [{ $size: '$realTimeStats' }, 0] },
+              then: {
+                $let: {
+                  vars: { stats: { $arrayElemAt: ['$realTimeStats', 0] } },
+                  in: {
+                    totalItems: '$$stats.totalItems',
+                    completedItems: '$$stats.completedItems',
+                    errorItems: '$$stats.errorItems'
+                  }
+                }
+              },
+              else: '$statistics'
+            }
+          }
         }
       },
       {
@@ -408,7 +444,7 @@ export class EvaluationTaskService {
     teamId: string,
     offset: number = 0,
     pageSize: number = 20
-  ): Promise<EvaluationItemListResponse> {
+  ): Promise<{ items: EvaluationItemDisplayType[]; total: number }> {
     const evaluation = await this.getEvaluation(evalId, teamId);
 
     const skip = offset;
@@ -552,7 +588,13 @@ export class EvaluationTaskService {
   static async getEvaluationStats(
     evalId: string,
     teamId: string
-  ): Promise<EvaluationStatsResponse> {
+  ): Promise<{
+    total: number;
+    completed: number;
+    evaluating: number;
+    queuing: number;
+    error: number;
+  }> {
     const evaluation = await this.getEvaluation(evalId, teamId);
 
     const [statsResult] = await MongoEvalItem.aggregate([
@@ -572,33 +614,18 @@ export class EvaluationTaskService {
           },
           error: {
             $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.error] }, 1, 0] }
-          },
-          avgScore: {
-            $avg: {
-              $cond: [
-                {
-                  $and: [
-                    { $eq: ['$status', EvaluationStatusEnum.completed] },
-                    { $ne: ['$evaluatorOutput.data.score', null] }
-                  ]
-                },
-                '$evaluatorOutput.data.score',
-                null
-              ]
-            }
           }
         }
       }
     ]);
 
     // Return stats with defaults for empty results
-    const result: EvaluationStatsResponse = {
+    const result = {
       total: statsResult?.total || 0,
       completed: statsResult?.completed || 0,
       evaluating: statsResult?.evaluating || 0,
       queuing: statsResult?.queuing || 0,
-      error: statsResult?.error || 0,
-      avgScore: statsResult?.avgScore ? Math.round(statsResult.avgScore * 100) / 100 : undefined
+      error: statsResult?.error || 0
     };
 
     return result;
@@ -856,13 +883,21 @@ export class EvaluationTaskService {
       return itemsToRetry.length;
     };
 
-    return await mongoSessionRun(retryItems);
+    const retriedCount = await mongoSessionRun(retryItems);
+
+    return retriedCount;
   }
 
   static async getEvaluationItemResult(
     itemId: string,
     teamId: string
-  ): Promise<EvaluationItemResultResponse> {
+  ): Promise<{
+    item: EvaluationItemSchemaType;
+    dataItem: EvaluationDataItemType;
+    response?: string;
+    result?: MetricResult;
+    score?: number;
+  }> {
     const item = await this.getEvaluationItem(itemId, teamId);
 
     return {
@@ -886,7 +921,7 @@ export class EvaluationTaskService {
       page?: number;
       pageSize?: number;
     } = {}
-  ): Promise<EvaluationItemListResponse> {
+  ): Promise<{ items: EvaluationItemDisplayType[]; total: number }> {
     const evaluation = await this.getEvaluation(evalId, teamId);
 
     const { status, hasError, scoreRange, keyword, page = 1, pageSize = 20 } = options;
@@ -950,7 +985,7 @@ export class EvaluationTaskService {
     evalId: string,
     teamId: string,
     format: 'csv' | 'json' = 'json'
-  ): Promise<EvaluationExportResponse> {
+  ): Promise<{ results: Buffer; total: number }> {
     const evaluation = await this.getEvaluation(evalId, teamId);
 
     const items = await MongoEvalItem.find({ evalId: evaluation._id })
@@ -1022,7 +1057,7 @@ export class EvaluationTaskService {
       offset?: number;
       pageSize?: number;
     }
-  ): Promise<DataItemGroupedResponse> {
+  ): Promise<DataItemListResponse> {
     const { evalId, status, keyword, offset = 0, pageSize = 20 } = options;
 
     // Verify team access to the evaluation task
@@ -1058,17 +1093,15 @@ export class EvaluationTaskService {
           },
           errorItems: {
             $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.error] }, 1, 0] }
-          },
-          avgScore: { $avg: '$evaluatorOutput.data.score' }
+          }
         }
       },
       {
         $addFields: {
           dataItemId: '$_id',
-          'summary.totalItems': '$totalItems',
-          'summary.completedItems': '$completedItems',
-          'summary.errorItems': '$errorItems',
-          'summary.avgScore': { $round: ['$avgScore', 2] }
+          'statistics.totalItems': '$totalItems',
+          'statistics.completedItems': '$completedItems',
+          'statistics.errorItems': '$errorItems'
         }
       },
       { $sort: { totalItems: -1 as const, _id: 1 as const } }
@@ -1094,11 +1127,10 @@ export class EvaluationTaskService {
                 }
               }
             },
-            summary: {
+            statistics: {
               totalItems: '$totalItems',
               completedItems: '$completedItems',
-              errorItems: '$errorItems',
-              avgScore: '$summary.avgScore'
+              errorItems: '$errorItems'
             }
           }
         }
@@ -1119,12 +1151,12 @@ export class EvaluationTaskService {
     dataItemId: string,
     teamId: string,
     evalId: string
-  ): Promise<BatchDeleteResponse> {
+  ): Promise<{ deletedCount: number }> {
     // Verify team access to the evaluation task
     await this.getEvaluation(evalId, teamId);
 
     const filter: any = {
-      'dataItem._id': dataItemId,
+      'dataItem._id': new Types.ObjectId(dataItemId),
       evalId: new Types.ObjectId(evalId)
     };
 
@@ -1167,12 +1199,12 @@ export class EvaluationTaskService {
     dataItemId: string,
     teamId: string,
     evalId: string
-  ): Promise<BatchRetryResponse> {
+  ): Promise<{ retriedCount: number }> {
     // Verify evaluation access first
     await this.getEvaluation(evalId, teamId);
 
     const filter: any = {
-      'dataItem._id': dataItemId,
+      'dataItem._id': new Types.ObjectId(dataItemId),
       evalId: new Types.ObjectId(evalId),
       status: EvaluationStatusEnum.error
     };
@@ -1253,7 +1285,7 @@ export class EvaluationTaskService {
     },
     teamId: string,
     evalId: string
-  ): Promise<BatchUpdateResponse> {
+  ): Promise<{ updatedCount: number }> {
     // Verify evaluation access first
     await this.getEvaluation(evalId, teamId);
 
@@ -1264,7 +1296,7 @@ export class EvaluationTaskService {
     }
 
     const filter: any = {
-      'dataItem._id': dataItemId,
+      'dataItem._id': new Types.ObjectId(dataItemId),
       evalId: new Types.ObjectId(evalId)
     };
 
@@ -1281,7 +1313,7 @@ export class EvaluationTaskService {
     teamId: string,
     evalId: string,
     format: 'csv' | 'json' = 'json'
-  ): Promise<EvaluationExportByDataItemResponse> {
+  ): Promise<{ results: Buffer; totalItems: number }> {
     // Get evaluation config for metric names
     const evaluation = await this.getEvaluation(evalId, teamId);
 
diff --git a/packages/service/core/evaluation/task/processor.ts b/packages/service/core/evaluation/task/processor.ts
index 8d6aea7839d9..eb819a8ba8c3 100644
--- a/packages/service/core/evaluation/task/processor.ts
+++ b/packages/service/core/evaluation/task/processor.ts
@@ -214,16 +214,6 @@ const finishEvaluationTask = async (evalId: string) => {
           },
           queuingCount: {
             $sum: { $cond: [{ $eq: ['$status', EvaluationStatusEnum.queuing] }, 1, 0] }
-          },
-          // Calculate average score only for successfully completed items
-          avgScore: {
-            $avg: {
-              $cond: [
-                { $eq: ['$status', EvaluationStatusEnum.completed] },
-                '$evaluatorOutput?.data?.score',
-                null
-              ]
-            }
           }
         }
       }
@@ -240,43 +230,42 @@ const finishEvaluationTask = async (evalId: string) => {
       completedCount = 0,
       errorCount = 0,
       evaluatingCount = 0,
-      queuingCount = 0,
-      avgScore = 0
+      queuingCount = 0
     } = statsResult;
 
     // Check if truly completed
     const pendingCount = evaluatingCount + queuingCount;
+
+    // Task status is always completed when all items are finished
+    let taskStatus: EvaluationStatusEnum = EvaluationStatusEnum.completed;
     if (pendingCount > 0) {
       addLog.debug(
         `[Evaluation] Task not yet completed: ${evalId}, pending items: ${pendingCount}`
       );
-      return; // Still have incomplete items, do not update task status
+      taskStatus = EvaluationStatusEnum.evaluating;
     }
 
-    // Task status is always completed when all items are finished
-    const taskStatus = EvaluationStatusEnum.completed;
-
     // Update task status with statistical fields
-    await MongoEvaluation.updateOne(
-      { _id: new Types.ObjectId(evalId) },
-      {
-        $set: {
-          finishTime: new Date(),
-          avgScore: avgScore != null ? Math.round(avgScore * 100) / 100 : undefined,
-          status: taskStatus,
-          // Use statistics object to store execution statistics
-          statistics: {
-            totalItems: totalCount,
-            completedItems: completedCount,
-            errorItems: errorCount
-          }
-        }
+    const updateFields: any = {
+      status: taskStatus,
+      // Use statistics object to store execution statistics
+      statistics: {
+        totalItems: totalCount,
+        completedItems: completedCount,
+        errorItems: errorCount
       }
-    );
+    };
+
+    // Only set finishTime if the task is actually completed
+    if (taskStatus === EvaluationStatusEnum.completed) {
+      updateFields.finishTime = new Date();
+    }
+
+    await MongoEvaluation.updateOne({ _id: new Types.ObjectId(evalId) }, { $set: updateFields });
 
     addLog.debug(
       `[Evaluation] Task completed: ${evalId}, status: ${taskStatus}, total: ${totalCount}, ` +
-        `success: ${completedCount}, failed: ${errorCount}, avg score: ${avgScore ? avgScore.toFixed(2) : 'N/A'}`
+        `success: ${completedCount}, failed: ${errorCount}`
     );
   } catch (error) {
     addLog.error(`[Evaluation] Error occurred while completing task: ${evalId}`, error);
@@ -672,14 +661,7 @@ const evaluationItemProcessor = async (job: Job<EvaluationItemJobData>) => {
 
   // After try-catch, check if all evaluation items are completed
   try {
-    const pendingCount = await MongoEvalItem.countDocuments({
-      evalId: new Types.ObjectId(evalId),
-      status: { $in: [EvaluationStatusEnum.queuing, EvaluationStatusEnum.evaluating] }
-    });
-
-    if (pendingCount === 0) {
-      await finishEvaluationTask(evalId);
-    }
+    await finishEvaluationTask(evalId);
   } catch (finishError) {
     addLog.error(
       `[Evaluation] Error occurred while checking task completion status: ${evalId}`,
diff --git a/projects/app/src/pageComponents/dashboard/evaluation/DetailModal.tsx b/projects/app/src/pageComponents/dashboard/evaluation/DetailModal.tsx
index 7175c60b2e5a..08ec378b1e15 100644
--- a/projects/app/src/pageComponents/dashboard/evaluation/DetailModal.tsx
+++ b/projects/app/src/pageComponents/dashboard/evaluation/DetailModal.tsx
@@ -281,7 +281,7 @@ const EvaluationDetailModal = ({
                     fontSize={14}
                     color={'myGray.900'}
                     fontWeight={'medium'}
-                    >{`${t('dashboard_evaluation:data_list')}: ${evalDetail?.totalCount}`}</Box>
+                  >{`${t('dashboard_evaluation:data_list')}: ${evalDetail?.totalCount}`}</Box>
                 </Flex>
 
                 <Button
diff --git a/projects/app/src/pages/api/core/evaluation/task/create.ts b/projects/app/src/pages/api/core/evaluation/task/create.ts
index 31bdb3c7b893..25b5406a06b7 100644
--- a/projects/app/src/pages/api/core/evaluation/task/create.ts
+++ b/projects/app/src/pages/api/core/evaluation/task/create.ts
@@ -19,7 +19,7 @@ import {
 async function handler(
   req: ApiRequestProps<CreateEvaluationRequest>
 ): Promise<CreateEvaluationResponse> {
-  const { name, description, datasetId, target, evaluators } = req.body;
+  const { name, description, datasetId, target, evaluators, autoStart } = req.body;
 
   // Validate all evaluation parameters (includes target validation)
   const paramValidation = await validateEvaluationParamsForCreate({
@@ -51,6 +51,7 @@ async function handler(
     datasetId,
     target: target as EvalTarget,
     evaluators,
+    autoStart,
     teamId,
     tmbId
   });
diff --git a/projects/app/src/pages/dashboard/evaluation/task/index.tsx b/projects/app/src/pages/dashboard/evaluation/task/index.tsx
index 7155249ffa44..c0667e5e7e5b 100644
--- a/projects/app/src/pages/dashboard/evaluation/task/index.tsx
+++ b/projects/app/src/pages/dashboard/evaluation/task/index.tsx
@@ -122,10 +122,11 @@ const EvaluationTasks = ({ Tab }: { Tab: React.ReactNode }) => {
       return <Box color={'myGray.600'}>{t('dashboard_evaluation:evaluating_status')}</Box>;
     }
 
-    if (task.status === EvaluationStatusEnum.completed && task.avgScore !== undefined) {
+    //todo replace by summary get api result
+    if (task.status === EvaluationStatusEnum.completed) {
       return (
         <Box color={'myGray.900'} fontWeight={'500'}>
-          {task.avgScore.toFixed(1)}
+          {100}
         </Box>
       );
     }
diff --git a/test/cases/pages/api/core/evaluation/task/create.test.ts b/test/cases/pages/api/core/evaluation/task/create.test.ts
index e4c254e198ee..e171eda90735 100644
--- a/test/cases/pages/api/core/evaluation/task/create.test.ts
+++ b/test/cases/pages/api/core/evaluation/task/create.test.ts
@@ -7,7 +7,6 @@ import {
   checkTeamEvaluationTaskLimit
 } from '@fastgpt/service/support/permission/teamLimit';
 import { validateTargetConfig } from '@fastgpt/service/core/evaluation/target';
-import { addLog } from '@fastgpt/service/common/system/log';
 import { EvaluationStatusEnum } from '@fastgpt/global/core/evaluation/constants';
 
 // Mock dependencies
@@ -140,6 +139,7 @@ describe('Create Evaluation Task API Handler', () => {
         datasetId: mockReq.body.datasetId,
         target: mockReq.body.target,
         evaluators: mockReq.body.evaluators,
+        autoStart: undefined, // 用户未传递 autoStart 参数时应该是 undefined，服务层会设置默认值
         teamId: mockTeamId,
         tmbId: mockTmbId
       })
@@ -147,6 +147,141 @@ describe('Create Evaluation Task API Handler', () => {
     expect(result).toEqual(mockEvaluation);
   });
 
+  test('应该成功创建评估任务并自动启动', async () => {
+    const mockTeamId = new Types.ObjectId().toString();
+    const mockTmbId = new Types.ObjectId().toString();
+
+    // Update mock to return consistent IDs
+    const { authEvaluationTaskCreate } = await import('@fastgpt/service/core/evaluation/common');
+    (authEvaluationTaskCreate as any).mockResolvedValue({
+      teamId: mockTeamId,
+      tmbId: mockTmbId
+    });
+
+    const mockAutoStartEvaluation = {
+      ...mockEvaluation,
+      status: EvaluationStatusEnum.evaluating // 自动启动后状态应该是 evaluating
+    };
+
+    const mockReq = {
+      method: 'POST',
+      body: {
+        name: 'Test Evaluation',
+        description: 'Test Description',
+        datasetId: new Types.ObjectId().toString(),
+        target: {
+          type: 'workflow',
+          config: {
+            appId: new Types.ObjectId().toString()
+          }
+        },
+        evaluators: [
+          {
+            metric: {
+              _id: new Types.ObjectId().toString(),
+              name: 'Test Metric',
+              type: 'ai_model',
+              config: { llm: 'gpt-4', prompt: 'test' },
+              dependencies: ['llm'],
+              teamId: new Types.ObjectId().toString(),
+              tmbId: new Types.ObjectId().toString(),
+              createTime: new Date(),
+              updateTime: new Date()
+            },
+            runtimeConfig: { llm: 'gpt-4' }
+          }
+        ],
+        autoStart: true // 测试自动启动
+      }
+    } as any;
+
+    (checkTeamAIPoints as any).mockResolvedValue(undefined);
+    (validateTargetConfig as any).mockResolvedValue({ isValid: true, errors: [] });
+    (EvaluationTaskService.createEvaluation as any).mockResolvedValue(mockAutoStartEvaluation);
+
+    const result = await createHandler(mockReq);
+
+    expect(EvaluationTaskService.createEvaluation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'Test Evaluation',
+        description: 'Test Description',
+        datasetId: mockReq.body.datasetId,
+        target: mockReq.body.target,
+        evaluators: mockReq.body.evaluators,
+        autoStart: true,
+        teamId: mockTeamId,
+        tmbId: mockTmbId
+      })
+    );
+    expect(result).toEqual(mockAutoStartEvaluation);
+    expect(result.status).toBe(EvaluationStatusEnum.evaluating);
+  });
+
+  test('应该支持显式关闭自动启动', async () => {
+    const mockTeamId = new Types.ObjectId().toString();
+    const mockTmbId = new Types.ObjectId().toString();
+
+    // Update mock to return consistent IDs
+    const { authEvaluationTaskCreate } = await import('@fastgpt/service/core/evaluation/common');
+    (authEvaluationTaskCreate as any).mockResolvedValue({
+      teamId: mockTeamId,
+      tmbId: mockTmbId
+    });
+
+    const mockReq = {
+      method: 'POST',
+      body: {
+        name: 'Test Evaluation',
+        description: 'Test Description',
+        datasetId: new Types.ObjectId().toString(),
+        target: {
+          type: 'workflow',
+          config: {
+            appId: new Types.ObjectId().toString()
+          }
+        },
+        evaluators: [
+          {
+            metric: {
+              _id: new Types.ObjectId().toString(),
+              name: 'Test Metric',
+              type: 'ai_model',
+              config: { llm: 'gpt-4', prompt: 'test' },
+              dependencies: ['llm'],
+              teamId: new Types.ObjectId().toString(),
+              tmbId: new Types.ObjectId().toString(),
+              createTime: new Date(),
+              updateTime: new Date()
+            },
+            runtimeConfig: { llm: 'gpt-4' }
+          }
+        ],
+        autoStart: false // 显式关闭自动启动
+      }
+    } as any;
+
+    (checkTeamAIPoints as any).mockResolvedValue(undefined);
+    (validateTargetConfig as any).mockResolvedValue({ isValid: true, errors: [] });
+    (EvaluationTaskService.createEvaluation as any).mockResolvedValue(mockEvaluation); // 状态仍然是 queuing
+
+    const result = await createHandler(mockReq);
+
+    expect(EvaluationTaskService.createEvaluation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'Test Evaluation',
+        description: 'Test Description',
+        datasetId: mockReq.body.datasetId,
+        target: mockReq.body.target,
+        evaluators: mockReq.body.evaluators,
+        autoStart: false,
+        teamId: mockTeamId,
+        tmbId: mockTmbId
+      })
+    );
+    expect(result).toEqual(mockEvaluation);
+    expect(result.status).toBe(EvaluationStatusEnum.queuing); // 未自动启动，状态保持为 queuing
+  });
+
   test('应该拒绝空名称', async () => {
     const mockReq = {
       method: 'POST',
diff --git a/test/cases/pages/api/core/evaluation/task/dataItem/list.test.ts b/test/cases/pages/api/core/evaluation/task/dataItem/list.test.ts
index 3a1224bb6304..5579799507b1 100644
--- a/test/cases/pages/api/core/evaluation/task/dataItem/list.test.ts
+++ b/test/cases/pages/api/core/evaluation/task/dataItem/list.test.ts
@@ -35,11 +35,10 @@ describe('List DataItems Grouped API Handler', () => {
         evaluatorOutput: { data: { score: 85 } }
       }
     ],
-    summary: {
+    statistics: {
       totalItems: 2,
       completedItems: 1,
-      errorItems: 0,
-      avgScore: 85
+      errorItems: 0
     }
   };
 
diff --git a/test/cases/pages/api/core/evaluation/task/stats.test.ts b/test/cases/pages/api/core/evaluation/task/stats.test.ts
index a7ef18d3d9ac..a8e750809bfc 100644
--- a/test/cases/pages/api/core/evaluation/task/stats.test.ts
+++ b/test/cases/pages/api/core/evaluation/task/stats.test.ts
@@ -34,8 +34,7 @@ describe('Get Evaluation Task Stats API Handler', () => {
       completed: 80,
       evaluating: 10,
       queuing: 5,
-      error: 5,
-      avgScore: 85.5
+      error: 5
     };
 
     (EvaluationTaskService.getEvaluationStats as any).mockResolvedValue(mockStats);
diff --git a/test/cases/service/core/evaluation/task.test.ts b/test/cases/service/core/evaluation/task.test.ts
index b42ffc9e44c2..68bdb3646a32 100644
--- a/test/cases/service/core/evaluation/task.test.ts
+++ b/test/cases/service/core/evaluation/task.test.ts
@@ -242,7 +242,7 @@ describe('EvaluationTaskService', () => {
       expect(evaluation.evaluators[0].runtimeConfig.llm).toBe('gpt-3.5-turbo');
       expect(evaluation.teamId.toString()).toBe(teamId);
       expect(evaluation.tmbId.toString()).toBe(tmbId);
-      expect(evaluation.status).toBe(EvaluationStatusEnum.queuing);
+      expect(evaluation.status).toBe(EvaluationStatusEnum.evaluating);
       expect(Types.ObjectId.isValid(evaluation.usageId)).toBe(true);
 
       // 验证创建用量记录被调用
@@ -261,6 +261,73 @@ describe('EvaluationTaskService', () => {
 
       await expect(EvaluationTaskService.createEvaluation(invalidParams as any)).rejects.toThrow();
     });
+
+    test('应该支持自动启动功能（默认值）', async () => {
+      const params: CreateEvaluationParams = {
+        name: 'Auto Start Test Evaluation',
+        description: 'Test evaluation with auto start',
+        datasetId,
+        target,
+        evaluators: evaluators
+        // autoStart 未指定，应使用默认值 true
+      };
+
+      const evaluation = await EvaluationTaskService.createEvaluation({
+        ...params,
+        teamId: teamId,
+        tmbId: tmbId
+      });
+
+      // 验证评估任务被创建且自动启动（状态应为 evaluating）
+      expect(evaluation.status).toBe(EvaluationStatusEnum.evaluating);
+      expect(evaluationTaskQueue.add).toHaveBeenCalledWith(`eval_task_${evaluation._id}`, {
+        evalId: evaluation._id.toString()
+      });
+    });
+
+    test('应该支持显式启用自动启动', async () => {
+      const params: CreateEvaluationParams = {
+        name: 'Explicit Auto Start Test',
+        description: 'Test evaluation with explicit auto start',
+        datasetId,
+        target,
+        evaluators: evaluators,
+        autoStart: true
+      };
+
+      const evaluation = await EvaluationTaskService.createEvaluation({
+        ...params,
+        teamId: teamId,
+        tmbId: tmbId
+      });
+
+      // 验证评估任务被创建且自动启动
+      expect(evaluation.status).toBe(EvaluationStatusEnum.evaluating);
+      expect(evaluationTaskQueue.add).toHaveBeenCalledWith(`eval_task_${evaluation._id}`, {
+        evalId: evaluation._id.toString()
+      });
+    });
+
+    test('应该支持关闭自动启动', async () => {
+      const params: CreateEvaluationParams = {
+        name: 'No Auto Start Test',
+        description: 'Test evaluation without auto start',
+        datasetId,
+        target,
+        evaluators: evaluators,
+        autoStart: false
+      };
+
+      const evaluation = await EvaluationTaskService.createEvaluation({
+        ...params,
+        teamId: teamId,
+        tmbId: tmbId
+      });
+
+      // 验证评估任务被创建但未自动启动（状态应为 queuing）
+      expect(evaluation.status).toBe(EvaluationStatusEnum.queuing);
+      expect(evaluationTaskQueue.add).not.toHaveBeenCalled();
+    });
   });
 
   describe('getEvaluation', () => {
@@ -283,7 +350,7 @@ describe('EvaluationTaskService', () => {
 
       expect(evaluation._id.toString()).toBe(created._id.toString());
       expect(evaluation.name).toBe('Get Test Evaluation');
-      expect(evaluation.status).toBe(EvaluationStatusEnum.queuing);
+      expect(evaluation.status).toBe(EvaluationStatusEnum.evaluating);
     });
 
     test('评估任务不存在时应该抛出错误', async () => {
@@ -401,7 +468,8 @@ describe('EvaluationTaskService', () => {
         description: 'Test evaluation for start operation',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const created = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -454,7 +522,8 @@ describe('EvaluationTaskService', () => {
         description: 'Test evaluation for restart operation',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const created = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -528,7 +597,8 @@ describe('EvaluationTaskService', () => {
         description: 'Test multiple restart operations',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const created = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -621,7 +691,8 @@ describe('EvaluationTaskService', () => {
         description: 'Test field cleanup during restart',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const created = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -670,8 +741,7 @@ describe('EvaluationTaskService', () => {
         {
           $set: {
             status: EvaluationStatusEnum.completed,
-            finishTime: new Date(),
-            avgScore: 85
+            finishTime: new Date()
           }
         }
       );
@@ -689,7 +759,8 @@ describe('EvaluationTaskService', () => {
         description: 'Test restarting running task',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const created = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -2256,7 +2327,8 @@ describe('EvaluationTaskService', () => {
         description: 'A test evaluation for data item operations',
         datasetId,
         target,
-        evaluators: evaluators
+        evaluators: evaluators,
+        autoStart: false
       };
       const evaluation = await EvaluationTaskService.createEvaluation({
         ...params,
@@ -2271,7 +2343,7 @@ describe('EvaluationTaskService', () => {
         {
           evalId: testEvaluationId,
           dataItem: {
-            _id: testDataItemId,
+            _id: new Types.ObjectId(testDataItemId),
             userInput: 'What is JavaScript?',
             expectedOutput: 'JavaScript is a programming language'
           },
@@ -2286,7 +2358,7 @@ describe('EvaluationTaskService', () => {
         {
           evalId: testEvaluationId,
           dataItem: {
-            _id: testDataItemId,
+            _id: new Types.ObjectId(testDataItemId),
             userInput: 'What is JavaScript?',
             expectedOutput: 'JavaScript is a programming language'
           },
@@ -2328,10 +2400,10 @@ describe('EvaluationTaskService', () => {
         expect(firstGroup.dataItemId).toBeDefined();
         expect(firstGroup.dataItem).toBeDefined();
         expect(firstGroup.items).toBeDefined();
-        expect(firstGroup.summary).toBeDefined();
-        expect(firstGroup.summary.totalItems).toBeGreaterThan(0);
-        expect(firstGroup.summary.completedItems).toBeGreaterThanOrEqual(0);
-        expect(firstGroup.summary.errorItems).toBeGreaterThanOrEqual(0);
+        expect(firstGroup.statistics).toBeDefined();
+        expect(firstGroup.statistics!.totalItems).toBeGreaterThan(0);
+        expect(firstGroup.statistics!.completedItems).toBeGreaterThanOrEqual(0);
+        expect(firstGroup.statistics!.errorItems).toBeGreaterThanOrEqual(0);
       });
 
       test('应该支持状态过滤', async () => {
@@ -2429,7 +2501,7 @@ describe('EvaluationTaskService', () => {
         // 验证失败的项目状态被重置
         const retriedItems = await MongoEvalItem.find({
           evalId: testEvaluationId,
-          'dataItem._id': testDataItemId,
+          'dataItem._id': new Types.ObjectId(testDataItemId),
           status: EvaluationStatusEnum.queuing
         });
         expect(retriedItems).toHaveLength(1);
@@ -2437,7 +2509,7 @@ describe('EvaluationTaskService', () => {
         // 验证成功的项目未受影响
         const completedItems = await MongoEvalItem.find({
           evalId: testEvaluationId,
-          'dataItem._id': testDataItemId,
+          'dataItem._id': new Types.ObjectId(testDataItemId),
           status: EvaluationStatusEnum.completed
         });
         expect(completedItems).toHaveLength(1);
@@ -2446,7 +2518,7 @@ describe('EvaluationTaskService', () => {
       test('没有失败项目时应该返回0', async () => {
         // 先将所有项目设为完成状态
         await MongoEvalItem.updateMany(
-          { evalId: testEvaluationId, 'dataItem._id': testDataItemId },
+          { evalId: testEvaluationId, 'dataItem._id': new Types.ObjectId(testDataItemId) },
           { $set: { status: EvaluationStatusEnum.completed } }
         );