114 lines
6.7 KiB
Python
114 lines
6.7 KiB
Python
"""Streaming-compatible LangChain tools backed by the shared component runtime."""
|
|
import asyncio
|
|
import hashlib
|
|
import json
|
|
import re
|
|
from django.db import close_old_connections
|
|
from rest_framework.exceptions import ValidationError
|
|
from system_manage import mcp_registry as registry, mcp_runtime as runtime
|
|
|
|
|
|
def context_for(body, *, engine_tools=None, tool_ids=None, custom=None, transform=None, node_id=None):
|
|
from application.models import Application, ApplicationKnowledgeMapping
|
|
from users.models import User
|
|
app = Application.objects.get(pk=body['application_id'], workspace_id=body['workspace_id'])
|
|
user = User.objects.get(pk=body.get('engine_user_id') or app.user_id, is_active=True)
|
|
knowledge_ids = body.get('knowledge_id_list')
|
|
if knowledge_ids is None:
|
|
knowledge_ids = list(ApplicationKnowledgeMapping.objects.filter(application=app).values_list('knowledge_id', flat=True))
|
|
return {'workspace': app.workspace_id, 'user': user, 'application_id': str(app.id), 'chat_id': body.get('chat_id'),
|
|
'parent': body.get('engine_task_id'), 'tool_ids': tool_ids or [], 'custom': custom,
|
|
'transform': transform, 'engine_tools': engine_tools or [],
|
|
'scope': {**{key: body.get(key) for key in ('chat_user_id', 'chat_user_type', 'knowledge_version_map', 'chat_record_id')},
|
|
'knowledge_setting': body.get('knowledge_setting') or {},
|
|
'viewer_id': str(body['chat_user_id']) if body.get('chat_user_type') in ('PLATFORM_USER', 'SYSTEM_USER') and body.get('chat_user_id') else None,
|
|
'knowledge_ids': [str(key) for key in knowledge_ids], 'fixed_knowledge_scope': True,
|
|
'node_id': node_id, 'source': 'workflow-chat' if node_id else 'knowledge-chat'}}
|
|
|
|
|
|
async def db_call(function, *args, **kwargs):
|
|
def run():
|
|
close_old_connections()
|
|
try:
|
|
return function(*args, **kwargs)
|
|
finally:
|
|
close_old_connections()
|
|
return await asyncio.to_thread(run)
|
|
|
|
|
|
def call_records(body, node_id=None):
|
|
from system_manage.models.ai_hub import AITask
|
|
if not body.get('chat_id'):
|
|
return []
|
|
query = AITask.objects.filter(workspace_id=body['workspace_id'], snapshot__trace__chat_id=str(body['chat_id']))
|
|
if body.get('chat_record_id'):
|
|
query = query.filter(snapshot__trace__chat_record_id=str(body['chat_record_id']))
|
|
if node_id:
|
|
query = query.filter(snapshot__trace__node_id=str(node_id))
|
|
return [{'id': str(task.id), 'status': task.status, 'component_id': task.snapshot.get('resources', [''])[0],
|
|
'artifact_id': task.result.get('artifact_id')} for task in query.order_by('created_at')[:50]]
|
|
|
|
|
|
async def tools(context):
|
|
from langchain_core.tools import StructuredTool
|
|
result = []
|
|
workspace, user = context['workspace'], context['user']
|
|
entries = []
|
|
for pk in dict.fromkeys(context['tool_ids']):
|
|
key = 'mcp:' + str(pk)
|
|
_, obj = await db_call(registry.resolve, workspace, user, key)
|
|
servers = runtime.connections(obj.code)
|
|
if context.get('transform'):
|
|
servers = context['transform'](servers)
|
|
entries.append((key, servers))
|
|
if context.get('custom'):
|
|
await db_call(registry.resolve, workspace, user, 'mcp-custom')
|
|
entries.append(('mcp-custom', runtime.connections(context['custom'])))
|
|
def bind_mcp(key, item, servers):
|
|
async def call(**arguments):
|
|
try:
|
|
output = await db_call(runtime.invoke, workspace, user, key,
|
|
{'servers': servers, 'server': item['server'], 'tool': item['name'], 'arguments': arguments},
|
|
parent=context.get('parent'), application_id=context['application_id'], chat_id=context.get('chat_id'),
|
|
scope=context.get('scope'), connection_overrides=servers, priority=8)
|
|
return json.dumps(output, ensure_ascii=False, default=str)
|
|
except ValidationError:
|
|
return json.dumps({'error': '工具不可用或执行失败,请检查工具状态后重试'}, ensure_ascii=False)
|
|
return call
|
|
discovered_entries = [(key, servers, await db_call(runtime.discover, servers)) for key, servers in entries]
|
|
from collections import Counter
|
|
def base_name(item):
|
|
return re.sub(r'[^a-zA-Z0-9_-]', '_', item['name'])[:40] or 'tool'
|
|
counts = Counter(base_name(item) for _, _, discovered in discovered_entries for item in discovered)
|
|
for key, servers, discovered in discovered_entries:
|
|
for item in discovered:
|
|
identity = key + ':' + item['server'] + ':' + item['name']
|
|
name = base_name(item)
|
|
alias = name if counts[name] == 1 and name == item['name'] and name not in ('search_knowledge', 'save_mindmap') else (
|
|
name + '_' + hashlib.sha256(identity.encode()).hexdigest()[:12])
|
|
result.append(StructuredTool.from_function(coroutine=bind_mcp(key, item, servers), name=alias,
|
|
description=f"{item['description']} ({item['server']} / {item['name']})", args_schema=item['args_schema']))
|
|
schemas = {
|
|
'knowledge-search': ('search_knowledge', '检索当前应用已关联且获授权的知识库,返回片段与文档引用。',
|
|
{'type': 'object', 'properties': {'text': {'type': 'string'}}, 'required': ['text']}),
|
|
'mindmap-save': ('save_mindmap', '将已整理的 Markdown 保存为可编辑思维导图,返回打开导图链接。仅在用户要求生成或保存导图时调用。',
|
|
{'type': 'object', 'properties': {'text': {'type': 'string'}, 'name': {'type': 'string'}}, 'required': ['text']}),
|
|
}
|
|
def bind_builtin(key):
|
|
async def call(**arguments):
|
|
value = await db_call(runtime.invoke, workspace, user, key, arguments,
|
|
parent=context.get('parent'), application_id=context['application_id'], chat_id=context.get('chat_id'),
|
|
scope=context.get('scope'), priority=8)
|
|
return json.dumps(value, ensure_ascii=False, default=str)
|
|
return call
|
|
for key in dict.fromkeys(context.get('engine_tools', [])):
|
|
if key not in schemas:
|
|
raise ValidationError('平台能力无效')
|
|
if key == 'mindmap-save' and context.get('scope', {}).get('chat_user_type') not in (None, 'PLATFORM_USER', 'SYSTEM_USER'):
|
|
# Saved workbench artifacts require a platform identity; public chat keeps its original behavior.
|
|
continue
|
|
await db_call(registry.resolve, workspace, user, key)
|
|
name, description, schema = schemas[key]
|
|
result.append(StructuredTool.from_function(coroutine=bind_builtin(key), name=name, description=description, args_schema=schema))
|
|
return result
|