@cicctencent/agent-midway 0.1.1

package/dist/service/a2a.service.js

@@ -0,0 +1,537 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AService = void 0;
+/**
+ * A2A (Agent-to-Agent) 协议服务
+ *
+ * 实现 A2A 协议核心功能：
+ * - Agent Card 生成（描述本机 Agent 能力）+ 30s TTL 缓存
+ * - JSON-RPC 2.0 分发（tasks/send, tasks/get, tasks/cancel）
+ * - 同步/流式任务执行
+ * - SSE 心跳机制（每 3 秒发送 keep-alive）
+ * - 事件映射表（EVENT_MAPPERS）
+ * - contextId → threadId LRU 映射（500 条上限）
+ * - 远程 Agent 发现 + A2A Client（支持 bearer/basic/apiKey/custom 认证）
+ *
+ * 参考 A2A 协议规范：https://github.com/google-a2a/A2A
+ */
+const core_1 = require("@midwayjs/core");
+const midwayjs_base_1 = require("@cicctencent/midwayjs-base");
+const agent_server_service_1 = require("./agent-server.service");
+const agent_core_1 = require("@cicctencent/agent-core");
+/** JSON-RPC 错误码 */
+const RPC_ERRORS = {
+    PARSE_ERROR: { code: -32700, message: 'Parse error' },
+    INVALID_REQUEST: { code: -32600, message: 'Invalid Request' },
+    METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },
+    INVALID_PARAMS: { code: -32602, message: 'Invalid params' },
+    INTERNAL_ERROR: { code: -32603, message: 'Internal error' },
+    TASK_NOT_FOUND: { code: -32001, message: 'Task not found' },
+    TASK_NOT_CANCELABLE: { code: -32002, message: 'Task not cancelable' },
+};
+// ---- 常量 ----
+const A2A_THREAD_MAP_MAX = 500;
+const CARD_CACHE_TTL = 30000; // 30 秒缓存
+const EVENT_MAPPERS = {
+    // content → message 事件（累积文本）
+    content: (e, taskId, contextId, acc) => {
+        const text = typeof e.data === 'string' ? e.data : '';
+        if (!text)
+            return null;
+        acc.finalContent += text;
+        return {
+            type: 'message',
+            data: {
+                role: 'agent',
+                parts: [{ kind: 'text', text: acc.finalContent }],
+                messageId: genId(),
+                taskId,
+                contextId,
+            },
+        };
+    },
+    // tool_call → data 事件
+    tool_call: (e, taskId, contextId) => ({
+        type: 'message',
+        data: {
+            role: 'agent',
+            parts: [{ kind: 'data', data: { type: 'tool_call', ...e.data } }],
+            messageId: genId(),
+            taskId,
+            contextId,
+        },
+    }),
+    // tool_result → data 事件
+    tool_result: (e, taskId, contextId) => ({
+        type: 'message',
+        data: {
+            role: 'agent',
+            parts: [{ kind: 'data', data: { type: 'tool_result', ...e.data } }],
+            messageId: genId(),
+            taskId,
+            contextId,
+        },
+    }),
+    // reasoning → thinking 事件
+    reasoning: (e, taskId, contextId) => ({
+        type: 'message',
+        data: {
+            role: 'agent',
+            parts: [{ kind: 'data', data: { type: 'thinking', content: e.data } }],
+            messageId: genId(),
+            taskId,
+            contextId,
+        },
+    }),
+};
+/** 透传任意引擎事件：将事件属性作为 metadata 直接转发 */
+function passthroughEvent(event, taskId, contextId) {
+    return {
+        type: 'message',
+        data: {
+            role: 'agent',
+            parts: [{ kind: 'data', data: { type: event.type, ...event.data } }],
+            messageId: genId(),
+            taskId,
+            contextId,
+        },
+    };
+}
+/** 生成唯一 ID */
+function genId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+let A2AService = class A2AService extends midwayjs_base_1.BaseService {
+    constructor() {
+        super(...arguments);
+        /** 任务存储（内存） */
+        this.tasks = new Map();
+        /** 运行中的任务 AbortController */
+        this.abortControllers = new Map();
+        /** contextId → threadId LRU 映射（同一会话多轮复用线程） */
+        this.a2aThreadMap = new Map();
+        /** 缓存的 Agent Card */
+        this.cachedCard = null;
+        this.cardGeneratedAt = 0;
+    }
+    // ---- Agent Card 缓存 ----
+    /** 生成 Agent Card（带 30s TTL 缓存） */
+    generateAgentCard(baseUrl) {
+        const now = Date.now();
+        if (this.cachedCard && now - this.cardGeneratedAt < CARD_CACHE_TTL) {
+            return { ...this.cachedCard, url: `${baseUrl || process.env.A2A_BASE_URL || 'http://localhost:7001'}/a2a` };
+        }
+        const url = baseUrl || process.env.A2A_BASE_URL || 'http://localhost:7001';
+        const card = {
+            name: 'AI Workstation Agent',
+            description: 'An AI agent powered by the workstation, supporting tool calls, memory, and streaming output.',
+            url: `${url}/a2a`,
+            version: '1.0.0',
+            capabilities: {
+                streaming: true,
+                pushNotifications: false,
+                stateTransitionHistory: true,
+            },
+            defaultInputModes: ['text'],
+            defaultOutputModes: ['text'],
+            skills: [
+                {
+                    id: 'chat',
+                    name: 'General Chat',
+                    description: 'General-purpose conversational AI assistant with tool calling capabilities.',
+                    tags: ['chat', 'general'],
+                    inputModes: ['text'],
+                    outputModes: ['text'],
+                },
+                {
+                    id: 'data-analyst',
+                    name: 'Data Analyst',
+                    description: 'AI agent specialized in data analysis, statistics, and visualization.',
+                    tags: ['data', 'analysis'],
+                    inputModes: ['text'],
+                    outputModes: ['text'],
+                },
+            ],
+        };
+        this.cachedCard = card;
+        this.cardGeneratedAt = now;
+        return card;
+    }
+    /** 使 Agent Card 缓存失效（profile 变更时调用） */
+    invalidateAgentCard() {
+        this.cachedCard = null;
+        this.cardGeneratedAt = 0;
+    }
+    // ---- contextId → threadId LRU 映射 ----
+    /** 获取 contextId 对应的 threadId */
+    getThreadForContext(contextId) {
+        return this.a2aThreadMap.get(contextId);
+    }
+    /** 设置 contextId → threadId 映射（LRU 淘汰） */
+    setThreadForContext(contextId, threadId) {
+        if (this.a2aThreadMap.size >= A2A_THREAD_MAP_MAX && !this.a2aThreadMap.has(contextId)) {
+            const oldestKey = this.a2aThreadMap.keys().next().value;
+            if (oldestKey !== undefined)
+                this.a2aThreadMap.delete(oldestKey);
+        }
+        this.a2aThreadMap.set(contextId, threadId);
+    }
+    /** JSON-RPC 2.0 分发 */
+    async handleJsonRpc(body) {
+        if (!body || typeof body !== 'object') {
+            return this.makeError(null, RPC_ERRORS.INVALID_REQUEST);
+        }
+        const { jsonrpc, id, method, params } = body;
+        if (jsonrpc !== '2.0') {
+            return this.makeError(id ?? null, RPC_ERRORS.INVALID_REQUEST);
+        }
+        try {
+            let result;
+            switch (method) {
+                case 'tasks/send':
+                    result = await this.handleSendTask(params);
+                    break;
+                case 'tasks/sendSubscribe':
+                    // 流式方法在 controller 中直接处理，这里返回提示
+                    return this.makeError(id, {
+                        code: -32000,
+                        message: 'Streaming method requires SSE connection. Use the /a2a endpoint with Accept: text/event-stream.',
+                    });
+                case 'tasks/get':
+                    result = await this.handleGetTask(params);
+                    break;
+                case 'tasks/cancel':
+                    result = await this.handleCancelTask(params);
+                    break;
+                default:
+                    return this.makeError(id, RPC_ERRORS.METHOD_NOT_FOUND);
+            }
+            return { jsonrpc: '2.0', id, result };
+        }
+        catch (error) {
+            return this.makeError(id, {
+                code: RPC_ERRORS.INTERNAL_ERROR.code,
+                message: error.message || 'Internal error',
+            });
+        }
+    }
+    /** 同步执行 Agent 任务 */
+    async handleSendTask(params) {
+        const taskId = params?.id || genId();
+        const contextId = params?.contextId || genId();
+        const message = params?.message;
+        const prompt = this.extractText(message);
+        if (!prompt) {
+            throw new Error('No text content found in message');
+        }
+        const task = {
+            id: taskId,
+            contextId,
+            state: 'submitted',
+            message,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            history: [],
+        };
+        this.tasks.set(taskId, task);
+        try {
+            task.state = 'working';
+            task.updatedAt = Date.now();
+            const result = await this.agentServerService.runAgent(prompt, {
+                userId: 'a2a-agent',
+                maxSteps: 20,
+                timeout: 120000,
+            });
+            const resultText = typeof result === 'string'
+                ? result
+                : result?.text || JSON.stringify(result);
+            task.result = {
+                role: 'agent',
+                parts: [{ kind: 'text', text: resultText }],
+                messageId: genId(),
+                taskId,
+                contextId,
+            };
+            task.state = 'completed';
+            task.updatedAt = Date.now();
+        }
+        catch (error) {
+            task.state = 'failed';
+            task.error = error.message;
+            task.updatedAt = Date.now();
+        }
+        return { task };
+    }
+    /** 流式执行 Agent 任务（带 SSE 心跳 + 事件映射表） */
+    async *handleSendTaskStreaming(params) {
+        const taskId = params?.id || genId();
+        const contextId = params?.contextId || genId();
+        const message = params?.message;
+        const prompt = this.extractText(message);
+        if (!prompt) {
+            yield {
+                type: 'error',
+                data: { message: 'No text content found in message' },
+            };
+            return;
+        }
+        const task = {
+            id: taskId,
+            contextId,
+            state: 'submitted',
+            message,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            history: [],
+        };
+        this.tasks.set(taskId, task);
+        const abortController = new AbortController();
+        this.abortControllers.set(taskId, abortController);
+        task.state = 'working';
+        task.updatedAt = Date.now();
+        yield {
+            type: 'task',
+            data: { id: taskId, state: 'working', contextId },
+        };
+        // 心跳定时器：每 3 秒触发 keep-alive
+        let heartbeatPending = false;
+        const heartbeatTimer = setInterval(() => {
+            heartbeatPending = true;
+        }, 3000);
+        if (heartbeatTimer && typeof heartbeatTimer === 'object' && 'unref' in heartbeatTimer) {
+            heartbeatTimer.unref();
+        }
+        try {
+            const generator = this.agentServerService.runAgentStream(prompt, {
+                userId: 'a2a-agent',
+                maxSteps: 20,
+                timeout: 120000,
+            });
+            const acc = { finalContent: '' };
+            const iterator = generator[Symbol.asyncIterator]();
+            let engineNext = null;
+            while (true) {
+                // 先发送心跳（如果 pending）
+                if (heartbeatPending) {
+                    heartbeatPending = false;
+                    yield { type: 'heartbeat', data: null };
+                }
+                // 等待下一个引擎事件 或 心跳超时（先到先用）
+                if (!engineNext) {
+                    engineNext = iterator.next();
+                }
+                // 创建心跳 Promise（3 秒后触发）
+                const heartbeatPromise = new Promise(resolve => {
+                    setTimeout(() => resolve('heartbeat'), 3000);
+                });
+                const raceResult = await Promise.race([
+                    engineNext.then(r => ({ type: 'engine', result: r })),
+                    heartbeatPromise.then(() => ({ type: 'heartbeat', result: null })),
+                ]);
+                if (raceResult.type === 'heartbeat') {
+                    // 心跳先到 — 发送 keep-alive，继续等待引擎
+                    yield { type: 'heartbeat', data: null };
+                    continue;
+                }
+                // 引擎事件到达 — 重置 engineNext
+                engineNext = null;
+                const { value: event, done } = raceResult.result;
+                if (done || !event)
+                    break;
+                if (abortController.signal.aborted) {
+                    break;
+                }
+                // ---- 使用事件映射表处理事件 ----
+                const mapper = EVENT_MAPPERS[event.type];
+                const a2aEvent = mapper
+                    ? mapper(event, taskId, contextId, acc)
+                    : passthroughEvent(event, taskId, contextId);
+                if (a2aEvent) {
+                    yield a2aEvent;
+                }
+                // done 事件：提取最终内容
+                if (event.type === 'done') {
+                    if (!acc.finalContent && event.data) {
+                        acc.finalContent =
+                            typeof event.data === 'string'
+                                ? event.data
+                                : event.data?.text ||
+                                    JSON.stringify(event.data);
+                    }
+                    break;
+                }
+                // error 事件
+                if (event.type === 'error') {
+                    yield {
+                        type: 'error',
+                        data: { message: String(event.data) },
+                    };
+                }
+            }
+            task.result = {
+                role: 'agent',
+                parts: [{ kind: 'text', text: acc.finalContent || 'Task completed.' }],
+                messageId: genId(),
+                taskId,
+                contextId,
+            };
+            task.state = abortController.signal.aborted
+                ? 'canceled'
+                : 'completed';
+            task.updatedAt = Date.now();
+        }
+        catch (error) {
+            task.state = 'failed';
+            task.error = error.message;
+            task.updatedAt = Date.now();
+            yield {
+                type: 'error',
+                data: { message: error.message },
+            };
+        }
+        finally {
+            clearInterval(heartbeatTimer);
+            this.abortControllers.delete(taskId);
+        }
+        yield {
+            type: 'done',
+            data: { id: taskId, state: task.state, result: task.result, contextId },
+        };
+    }
+    /** 获取任务 */
+    async handleGetTask(params) {
+        const taskId = params?.id;
+        if (!taskId) {
+            throw new Error('Task ID is required');
+        }
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error('Task not found');
+        }
+        return { task };
+    }
+    /** 取消任务 */
+    async handleCancelTask(params) {
+        const taskId = params?.id;
+        if (!taskId) {
+            throw new Error('Task ID is required');
+        }
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error('Task not found');
+        }
+        if (task.state !== 'working' && task.state !== 'submitted') {
+            throw new Error('Task is not cancelable');
+        }
+        const abortController = this.abortControllers.get(taskId);
+        if (abortController) {
+            abortController.abort();
+        }
+        task.state = 'canceled';
+        task.updatedAt = Date.now();
+        return { task };
+    }
+    /** 发现远程 Agent（使用 A2AClient，支持 bearer/basic/apiKey/custom 认证） */
+    async discoverRemoteAgent(url, auth) {
+        // 兼容旧接口：auth 为字符串时视为 raw Authorization header
+        const authConfig = typeof auth === 'string'
+            ? { type: 'custom', value: auth, name: 'Authorization' }
+            : auth;
+        const headers = (0, agent_core_1.buildAuthHeaders)(authConfig || null);
+        const client = new agent_core_1.A2AClient({ timeout: 300000, headers });
+        return client.discoverAgent(url);
+    }
+    /**
+     * 将远程 Agent Profile 包装为 SubAgentRunner，供 delegate_task 使用
+     * 支持 JSON-RPC A2A 和 REST A2A 两种协议
+     */
+    createRunnerFromProfile(profile) {
+        const headers = (0, agent_core_1.buildAuthHeaders)(profile.remoteAuth || null);
+        // ---- REST 风格 A2A ----
+        if (profile.a2aProtocol === 'rest') {
+            const restConfig = profile.restA2AConfig;
+            if (!restConfig?.capabilityId) {
+                throw new Error(`REST A2A profile '${profile.name}' missing capabilityId in restA2AConfig`);
+            }
+            const client = new agent_core_1.RestA2AClient({ timeout: 300000, headers });
+            const runner = (0, agent_core_1.createRestA2ARemoteRunner)({
+                baseUrl: profile.remoteUrl,
+                capabilityId: restConfig.capabilityId,
+                name: `[Remote] ${profile.name}`,
+                description: `${profile.description || profile.name} (via REST A2A)`,
+                client,
+                staticFields: restConfig.staticFields,
+                taskField: restConfig.taskField,
+                streaming: true,
+            });
+            return {
+                ...runner,
+                priority: profile.priority ?? 0,
+                scope: profile.scope,
+                keywords: profile.keywords,
+                exclusiveScope: profile.exclusiveScope,
+            };
+        }
+        // ---- 标准 JSON-RPC A2A（默认）----
+        const client = new agent_core_1.A2AClient({ timeout: 300000, headers });
+        const agentUrl = resolveA2AEndpoint(profile.remoteUrl);
+        const runner = (0, agent_core_1.createA2ARemoteRunner)({
+            agentUrl,
+            name: `[Remote] ${profile.name}`,
+            description: `${profile.description || profile.name} (via A2A)`,
+            streaming: true,
+            client,
+            skillId: `specialist_${profile.id}`,
+        });
+        return {
+            ...runner,
+            priority: profile.priority ?? 0,
+            scope: profile.scope,
+            keywords: profile.keywords,
+            exclusiveScope: profile.exclusiveScope,
+        };
+    }
+    /** 从 A2A 消息中提取文本 */
+    extractText(message) {
+        if (!message)
+            return '';
+        const parts = message.parts || [];
+        return parts
+            .filter(p => p.kind === 'text' && p.text)
+            .map(p => p.text)
+            .join('\n');
+    }
+    /** 构造 JSON-RPC 错误响应 */
+    makeError(id, error) {
+        return {
+            jsonrpc: '2.0',
+            id: id ?? null,
+            error: { code: error.code, message: error.message },
+        };
+    }
+};
+exports.A2AService = A2AService;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", agent_server_service_1.AgentServerService)
+], A2AService.prototype, "agentServerService", void 0);
+exports.A2AService = A2AService = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], A2AService);
+/** 将用户输入的基础 URL 规范化为 A2A JSON-RPC 端点 URL */
+function resolveA2AEndpoint(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    if (trimmed.endsWith('/a2a'))
+        return trimmed;
+    return `${trimmed}/a2a`;
+}

package/dist/service/agent-profile.service.d.ts

@@ -0,0 +1,34 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import { DataSource, Repository } from 'typeorm';
+import AIAgentProfileEntity from '../model/ai-agent-profile.entity';
+/**
+ * Agent Profile 服务
+ * 管理 Agent 配置、Prompt、工具绑定等
+ */
+export declare class AgentProfileService extends BaseService {
+    dataSource: DataSource;
+    private repo?;
+    get model(): Repository<AIAgentProfileEntity>;
+    /** 获取所有 Profile（按应用隔离） */
+    list(applicationId: number, _options?: {
+        includeDisabled?: boolean;
+    }): Promise<AIAgentProfileEntity[]>;
+    /** 获取单个 Profile */
+    get(id: number, applicationId?: number): Promise<AIAgentProfileEntity>;
+    /** 获取默认 Profile */
+    getDefault(applicationId: number): Promise<AIAgentProfileEntity>;
+    /** 创建 Profile */
+    create(applicationId: number, data: Partial<AIAgentProfileEntity>): Promise<AIAgentProfileEntity>;
+    /** 更新 Profile */
+    update(id: number, applicationId: number, data: Partial<AIAgentProfileEntity>): Promise<AIAgentProfileEntity>;
+    /** 删除 Profile */
+    delete(id: number, applicationId: number): Promise<void>;
+    /** 设置为默认 */
+    setDefault(id: number, applicationId: number): Promise<AIAgentProfileEntity>;
+    /** 获取 Profile 完整配置（包含关联的 MCP Server 和 Skill） */
+    getFullConfig(id: number, applicationId: number): Promise<{
+        profile: AIAgentProfileEntity;
+        mcpServers: any[];
+        skills: any[];
+    }>;
+}

package/dist/service/agent-profile.service.js

@@ -0,0 +1,110 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentProfileService = void 0;
+const core_1 = require("@midwayjs/core");
+const midwayjs_base_1 = require("@cicctencent/midwayjs-base");
+const typeorm_1 = require("@midwayjs/typeorm");
+const typeorm_2 = require("typeorm");
+const ai_agent_profile_entity_1 = __importDefault(require("../model/ai-agent-profile.entity"));
+/**
+ * Agent Profile 服务
+ * 管理 Agent 配置、Prompt、工具绑定等
+ */
+let AgentProfileService = class AgentProfileService extends midwayjs_base_1.BaseService {
+    get model() {
+        if (this.repo)
+            return this.repo;
+        return (this.repo =
+            this.dataSource.getRepository(ai_agent_profile_entity_1.default));
+    }
+    /** 获取所有 Profile（按应用隔离） */
+    async list(applicationId, _options) {
+        const where = { applicationId };
+        return this.model.find({
+            where,
+            order: { isDefault: 'DESC', createTime: 'DESC' },
+        });
+    }
+    /** 获取单个 Profile */
+    async get(id, applicationId) {
+        const where = { id };
+        if (applicationId)
+            where.applicationId = applicationId;
+        return this.model.findOne({ where });
+    }
+    /** 获取默认 Profile */
+    async getDefault(applicationId) {
+        return this.model.findOne({ where: { applicationId, isDefault: 1 } });
+    }
+    /** 创建 Profile */
+    async create(applicationId, data) {
+        // 如果设置为默认，先清除其他默认
+        if (data.isDefault === 1) {
+            await this.model.update({ applicationId, isDefault: 1 }, { isDefault: 0 });
+        }
+        const profile = this.model.create({ ...data, applicationId });
+        return this.model.save(profile);
+    }
+    /** 更新 Profile */
+    async update(id, applicationId, data) {
+        // 如果设置为默认，先清除其他默认
+        if (data.isDefault === 1) {
+            await this.model.update({ applicationId, isDefault: 1 }, { isDefault: 0 });
+        }
+        await this.model.update({ id, applicationId }, data);
+        return this.get(id, applicationId);
+    }
+    /** 删除 Profile */
+    async delete(id, applicationId) {
+        await this.model.delete({ id, applicationId });
+    }
+    /** 设置为默认 */
+    async setDefault(id, applicationId) {
+        await this.model.update({ applicationId, isDefault: 1 }, { isDefault: 0 });
+        await this.model.update({ id, applicationId }, { isDefault: 1 });
+        return this.get(id, applicationId);
+    }
+    /** 获取 Profile 完整配置（包含关联的 MCP Server 和 Skill） */
+    async getFullConfig(id, applicationId) {
+        const profile = await this.get(id, applicationId);
+        if (!profile)
+            return null;
+        // 加载关联的 MCP Server
+        let mcpServers = [];
+        if (profile.mcpServers && profile.mcpServers.length > 0) {
+            mcpServers = await this.dataSource.query('SELECT * FROM t_mcp_server WHERE id IN (?) AND Fapplication_id = ?', [profile.mcpServers, applicationId]);
+        }
+        // 加载关联的 Skill
+        let skills = [];
+        if (profile.selectedSkills && profile.selectedSkills.length > 0) {
+            // Skill 存储在文件中，需要通过 AISkillService 获取
+            // 这里返回 ID 列表，由上层服务加载
+            skills = profile.selectedSkills;
+        }
+        return {
+            profile,
+            mcpServers,
+            skills,
+        };
+    }
+};
+exports.AgentProfileService = AgentProfileService;
+__decorate([
+    (0, typeorm_1.InjectDataSource)('default'),
+    __metadata("design:type", typeorm_2.DataSource)
+], AgentProfileService.prototype, "dataSource", void 0);
+exports.AgentProfileService = AgentProfileService = __decorate([
+    (0, core_1.Provide)()
+], AgentProfileService);