UnisKB/apps/system_manage/views/mcp_engine.py

172 lines
11 KiB
Python

import json
from datetime import timedelta
from django.db import transaction
from django.utils import timezone
from rest_framework.views import APIView
from rest_framework.exceptions import ValidationError, PermissionDenied, NotFound
from common.log.log import log
from common.auth import TokenAuth
from common.result import result
from system_manage import ai_hub as hub, mcp_registry as registry, mcp_scheduler as scheduler, mcp_workflows
from system_manage.models.ai_hub import AITask, AIFlow
def task_data(task, detail=False):
data = {'id': str(task.id), 'name': task.name, 'status': task.status, 'attempt': task.attempt,
'priority': task.snapshot.get('priority', 5), 'resources': scheduler.resources(task),
'created_at': task.created_at, 'started_at': task.started_at, 'finished_at': task.finished_at,
'error': task.error, 'dispatch': task.snapshot.get('dispatch', 'worker'),
'application_id': task.snapshot.get('application_id'), 'application_version': task.snapshot.get('application_version'),
'trace': task.snapshot.get('trace', {}), 'source': task.snapshot.get('source'),
'waiting_reason': '等待资源或执行器' if task.status == 'PENDING' else ''}
if detail:
data.update(steps=task.steps, result=task.result)
return data
class EngineView(APIView):
authentication_classes = [TokenAuth]
def initial(self, request, *args, **kwargs):
super().initial(request, *args, **kwargs)
from users.serializers.user import get_workspace_list_by_user
from system_manage.platform_access import module_list
if not request.user.is_active or kwargs['workspace_id'] not in {str(w['id']) for w in get_workspace_list_by_user(request.user.id)}:
raise PermissionDenied('无权访问当前工作空间')
if not {'application', 'mindmap', 'tool'} & set(module_list(request.user)):
raise PermissionDenied('未授权使用组件编排')
def get(self, request, workspace_id, kind):
user = request.user
if kind == 'workbench_flows':
return result.success(mcp_workflows.workbench_flows(workspace_id, user))
if kind == 'components':
rows = registry.catalogue(workspace_id, user)
running = AITask.objects.filter(status='RUNNING').only('snapshot')
from collections import Counter
counts = Counter(key for task in running for key in scheduler.resources(task))
return result.success({'records': [{**row, 'running': counts[row['id']]} for row in rows],
'capacity': registry.settings_row().meta.get('capacity', 4),
'interactive_reserve': registry.settings_row().meta.get('interactive_reserve', 1), 'worker_online': scheduler.worker_online(), 'is_admin': hub.admin(user)})
if kind == 'flows':
from application.models import Application
query = Application.objects.filter(workspace_id=workspace_id, type='WORK_FLOW')
if not hub.admin(user): query = query.filter(user_id=user.id)
apps = [{'id': str(app.id), 'name': app.name, 'kind': 'application', 'published': app.is_publish,
'updated_at': app.update_time} for app in query.order_by('-update_time')[:200]]
flows = hub.visible(AIFlow.objects.filter(workspace_id=workspace_id), user)
return result.success(apps + [{'id': str(flow.id), 'name': flow.name, 'kind': 'mindmap', 'published': True,
'revision': flow.revision, 'updated_at': flow.updated_at} for flow in flows.order_by('-updated_at')[:200]])
if kind == 'tasks':
from rest_framework import serializers
class Query(serializers.Serializer):
page = serializers.IntegerField(default=1, min_value=1)
page_size = serializers.IntegerField(default=20, min_value=1, max_value=100)
status = serializers.ChoiceField(choices=['', 'PENDING', 'RUNNING', 'SUCCESS', 'FAILED', 'CANCELLED'], required=False)
query = Query(data=request.query_params); query.is_valid(raise_exception=True)
params = query.validated_data
tasks = AITask.objects.filter(workspace_id=workspace_id)
if not hub.admin(user):
from django.db.models import Q
tasks = tasks.filter(Q(owner_id=user.id) | Q(snapshot__trace__viewer_id=str(user.id)))
if params.get('status'): tasks = tasks.filter(status=params['status'])
for key in ('application_id', 'chat_id', 'chat_record_id'):
if request.query_params.get(key):
value = str(serializers.UUIDField().run_validation(request.query_params[key]))
from django.db.models import Q
tasks = tasks.filter(Q(**{'snapshot__trace__' + key: value}) | Q(**{'snapshot__' + key: value}))
if request.query_params.get('id'):
pk = serializers.UUIDField().run_validation(request.query_params['id'])
task = tasks.filter(pk=pk).first()
if not task: raise NotFound('任务不存在')
return result.success(task_data(task, detail=True))
total, size = tasks.count(), params['page_size']
page = min(params['page'], max(1, (total + size - 1) // size))
records = tasks.defer('file_data', 'input_data', 'result', 'steps').order_by('-created_at', '-id')[(page-1)*size:page*size]
return result.success({'records': [task_data(task) for task in records], 'total': total, 'current': page})
raise NotFound()
@log(menu='MCP引擎', operate='管理组件与任务', get_details=lambda request: {
'kind': request.path.rsplit('/', 1)[-1], **{key: request.data.get(key) for key in ('id', 'state', 'capacity', 'priority') if key in request.data}})
def post(self, request, workspace_id, kind):
data = request.data
if request.FILES:
try: data = json.loads(request.data.get('data', '{}'))
except (ValueError, TypeError): raise ValidationError('任务参数无效')
if not isinstance(data, dict): raise ValidationError('请求参数无效')
user = request.user
if kind == 'components':
return result.success(registry.configure(workspace_id, user, data.get('id', ''), data))
if kind == 'recover':
hub.require_admin(user)
return result.success({'recovered': scheduler.recover()})
if kind == 'capacity':
hub.require_admin(user)
with transaction.atomic():
row = registry.settings_row(lock=True)
row.meta = {**row.meta, 'capacity': hub.integer(data.get('capacity'), 1, 32, '总执行容量'),
'interactive_reserve': hub.integer(data.get('interactive_reserve', 1), 0, 31, '交互预留容量')}
row.save(update_fields=['meta', 'update_time'])
return result.success(True)
if kind == 'probe':
hub.require_admin(user)
metadata, obj = registry.resolve(workspace_id, user, data.get('id', ''), check=False)
health = 'READY'
try:
if metadata['kind'] == 'parser': hub.parser_test(obj)
elif metadata['kind'] == 'mcp' and obj:
from system_manage.mcp_runtime import discover
discover(obj.code)
elif metadata['kind'] == 'model': health = 'CONFIGURED'
elif metadata['id'] == 'mcp-custom': health = 'CONFIGURED'
except Exception:
health = 'UNREACHABLE'
with transaction.atomic():
row = registry.settings_row(lock=True)
components = row.meta.setdefault('components', {})
components[metadata['id']] = {**components.get(metadata['id'], {}), 'health': health,
'checked_at': timezone.now().isoformat()}
row.save(update_fields=['meta', 'update_time'])
return result.success({'health': health})
if kind == 'tools':
from system_manage.mcp_runtime import discover
key = data.get('id', '')
_, obj = registry.resolve(workspace_id, user, key)
if not key.startswith('mcp:'):
raise ValidationError('请选择已注册的 MCP 工具')
return result.success(discover(obj.code))
if kind == 'flows':
app = mcp_workflows.new_template(workspace_id, user, data)
return result.success({'id': str(app.id)})
if kind == 'tasks':
if data.get('flow_kind') == 'mindmap':
from system_manage.platform_access import module_list
if 'mindmap' not in module_list(user): raise PermissionDenied('未授权使用思维导图')
task = hub.submit(workspace_id, user, {'flow_id': data.get('flow_id'), 'markdown': data.get('question', ''),
'priority': data.get('priority', 5)}, request.FILES.get('file'), request=request)
else:
from system_manage.access_control import enforce
enforce(request, 'application', data.get('application_id'))
task = mcp_workflows.submit(workspace_id, user, data, request.FILES.get('file'))
return result.success(task_data(task))
if kind in ('cancel', 'retry', 'priority'):
with transaction.atomic():
task = hub.one('tasks', data.get('id'), workspace_id, user, edit=True, lock=True)
if kind == 'cancel': scheduler.cancel(task)
elif kind == 'priority':
if task.status != 'PENDING': raise ValidationError('仅排队任务可调整优先级')
task.snapshot = {**task.snapshot, 'priority': hub.integer(data.get('priority'), 0, 9, '优先级')}
task.save(update_fields=['snapshot', 'updated_at'])
else:
if task.status not in ('FAILED', 'CANCELLED'): raise ValidationError('仅失败或取消的任务可重试')
if task.snapshot.get('dispatch') == 'inline': raise ValidationError('请在原高级编排中重新运行该节点')
for key in scheduler.resources(task): registry.resolve(workspace_id, user, key)
if AITask.objects.filter(owner_id=user.id, status__in=scheduler.ACTIVE).count() >= 10:
raise ValidationError('待处理任务已达上限')
task.status, task.error, task.steps = 'PENDING', '', []
task.attempt += 1
task.started_at = task.finished_at = None
task.save()
return result.success(True)
raise NotFound()