@cicctencent/agent-midway 0.1.1

package/dist/service/openai.service.js

@@ -0,0 +1,406 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.OpenAIService = void 0;
+const core_1 = require("@midwayjs/core");
+/**
+ * OpenAI 基础服务
+ * 封装 OpenAI API 调用，提供通用对话、流式输出、模型容错降级等基础能力
+ */
+let OpenAIService = class OpenAIService {
+    constructor() {
+        this.client = null;
+    }
+    async init() {
+        try {
+            const { default: OpenAI } = await Promise.resolve().then(() => __importStar(require('openai')));
+            if (this.openaiConfig?.apiKey) {
+                this.client = new OpenAI({
+                    apiKey: this.openaiConfig.apiKey,
+                    baseURL: this.openaiConfig.baseUrl,
+                });
+                console.log('[OpenAI] initialized, model:', this.openaiConfig.model, 'baseUrl:', this.openaiConfig.baseUrl);
+            }
+            else {
+                console.warn('[OpenAI] apiKey not configured, AI generation will be unavailable');
+            }
+        }
+        catch (e) {
+            console.warn('[OpenAI] openai package not installed, run: npm install openai');
+        }
+    }
+    isAvailable() {
+        return !!this.client;
+    }
+    // ===================== 通用对话流式接口 =====================
+    /**
+     * 通用 AI 对话流式输出
+     * 支持多轮对话上下文，返回 SSE 事件流
+     */
+    async *chatStream(messages, systemPrompt) {
+        if (!this.client) {
+            throw new Error('OpenAI 未配置或 openai 包未安装');
+        }
+        const defaultSystemPrompt = systemPrompt ||
+            '你是一个智能助手，能够帮助用户完成各种任务。请用中文回答，回答要专业但易于理解。';
+        const finalMessages = [];
+        if (systemPrompt) {
+            finalMessages.push({ role: 'system', content: systemPrompt });
+        }
+        finalMessages.push(...messages);
+        try {
+            const response = await this.client.chat.completions.create({
+                model: this.openaiConfig.model,
+                messages: finalMessages,
+                max_tokens: this.openaiConfig.maxTokens,
+                temperature: this.openaiConfig.temperature,
+                stream: true,
+            });
+            let reasoningContent = '';
+            let contentBuffer = '';
+            for await (const chunk of response) {
+                const delta = chunk.choices?.[0]?.delta;
+                if (!delta)
+                    continue;
+                // 推理内容
+                const reasoning = delta?.reasoning_content ||
+                    delta?.reasoning ||
+                    delta?.thinking ||
+                    '';
+                if (reasoning) {
+                    reasoningContent += reasoning;
+                    yield { event: 'reasoning', data: reasoning };
+                }
+                // 正文内容
+                if (delta.content) {
+                    contentBuffer += delta.content;
+                    yield { event: 'content', data: delta.content };
+                }
+            }
+            if (reasoningContent) {
+                yield { event: 'reasoning-done', data: null };
+            }
+            yield { event: 'done', data: contentBuffer };
+        }
+        catch (e) {
+            // 如果流式不支持，降级为普通调用
+            console.warn('[OpenAI] 流式调用失败，降级为普通调用:', e.message);
+            const result = await this.chatCompletion(defaultSystemPrompt, messages.map(m => m.content).join('\n') ||
+                messages[messages.length - 1]?.content ||
+                '');
+            if (result.reasoningContent) {
+                yield { event: 'reasoning', data: result.reasoningContent };
+                yield { event: 'reasoning-done', data: null };
+            }
+            yield { event: 'content', data: result.content };
+            yield { event: 'done', data: result.content };
+        }
+    }
+    // ===================== 通用完成接口 =====================
+    /**
+     * 通用 AI 对话完整调用（非流式）
+     */
+    async chatCompletion(systemPrompt, userMessage, modelOverride) {
+        if (!this.client) {
+            throw new Error('OpenAI 未配置或 openai 包未安装');
+        }
+        const response = await this.client.chat.completions.create({
+            model: modelOverride || this.openaiConfig.model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: userMessage },
+            ],
+            max_tokens: this.openaiConfig.maxTokens,
+            temperature: this.openaiConfig.temperature,
+        });
+        const message = response.choices?.[0]?.message;
+        return {
+            content: message?.content || '',
+            reasoningContent: message?.reasoning_content ||
+                message?.reasoning ||
+                message?.thinking ||
+                '',
+        };
+    }
+    // ===================== 流式辅助方法 =====================
+    /**
+     * 带工具调用的单轮流式对话
+     * 子类可传入自定义 tools 参数覆盖默认行为
+     */
+    async *streamToolRound(messages, modelOverride, tools) {
+        if (!this.client) {
+            throw new Error('OpenAI 未配置或 openai 包未安装');
+        }
+        const createParams = {
+            model: modelOverride || this.openaiConfig.model,
+            messages,
+            max_tokens: this.openaiConfig.maxTokens,
+            temperature: this.openaiConfig.temperature,
+            stream: true,
+        };
+        if (tools && tools.length > 0) {
+            createParams.tools = tools;
+            createParams.tool_choice = 'auto';
+        }
+        const stream = await this.client.chat.completions.create(createParams);
+        const toolCalls = [];
+        let reasoningContent = '';
+        let content = '';
+        for await (const chunk of stream) {
+            const delta = chunk?.choices?.[0]?.delta || {};
+            const reasoningText = this.extractReasoningText(delta);
+            if (reasoningText) {
+                reasoningContent += reasoningText;
+                yield { kind: 'reasoning', text: reasoningText };
+            }
+            const contentText = this.extractContentText(delta);
+            if (contentText) {
+                content += contentText;
+                yield { kind: 'content', text: contentText };
+            }
+            if (Array.isArray(delta.tool_calls)) {
+                for (const deltaToolCall of delta.tool_calls) {
+                    this.mergeToolCallDelta(toolCalls, deltaToolCall);
+                }
+            }
+        }
+        yield {
+            kind: 'result',
+            message: {
+                role: 'assistant',
+                content,
+                tool_calls: this.normalizeToolCalls(toolCalls),
+                reasoning_content: reasoningContent,
+            },
+        };
+    }
+    /**
+     * 从消息列表中流式输出对话内容
+     */
+    async *streamCompletionFromMessages(messages, modelOverride) {
+        if (!this.client) {
+            throw new Error('OpenAI 未配置或 openai 包未安装');
+        }
+        const stream = await this.client.chat.completions.create({
+            model: modelOverride || this.openaiConfig.model,
+            messages,
+            max_tokens: this.openaiConfig.maxTokens,
+            temperature: this.openaiConfig.temperature,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const delta = chunk?.choices?.[0]?.delta || {};
+            const reasoningText = this.extractReasoningText(delta);
+            if (reasoningText) {
+                yield { kind: 'reasoning', text: reasoningText };
+            }
+            const contentText = this.extractContentText(delta);
+            if (contentText) {
+                yield { kind: 'content', text: contentText };
+            }
+        }
+    }
+    // ===================== 文本提取辅助 =====================
+    normalizeTextPayload(payload) {
+        if (!payload)
+            return '';
+        if (typeof payload === 'string')
+            return payload;
+        if (Array.isArray(payload)) {
+            return payload
+                .map(item => {
+                if (typeof item === 'string')
+                    return item;
+                if (typeof item?.text === 'string')
+                    return item.text;
+                if (typeof item?.content === 'string')
+                    return item.content;
+                return '';
+            })
+                .join('');
+        }
+        if (typeof payload?.text === 'string')
+            return payload.text;
+        if (typeof payload?.content === 'string')
+            return payload.content;
+        return '';
+    }
+    extractReasoningText(message) {
+        return this.normalizeTextPayload(message?.reasoning_content ||
+            message?.reasoning ||
+            message?.thinking);
+    }
+    extractContentText(message) {
+        return this.normalizeTextPayload(message?.content);
+    }
+    // ===================== 工具调用辅助 =====================
+    parseToolArguments(rawArgs) {
+        if (!rawArgs)
+            return {};
+        try {
+            return JSON.parse(rawArgs);
+        }
+        catch (e) {
+            console.warn('[OpenAI] 工具参数解析失败:', rawArgs);
+            return {};
+        }
+    }
+    mergeToolCallDelta(target, deltaToolCall) {
+        const index = typeof deltaToolCall?.index === 'number'
+            ? deltaToolCall.index
+            : target.length;
+        if (!target[index]) {
+            target[index] = {
+                id: '',
+                type: 'function',
+                function: {
+                    name: '',
+                    arguments: '',
+                },
+            };
+        }
+        if (deltaToolCall?.id) {
+            target[index].id += deltaToolCall.id;
+        }
+        if (deltaToolCall?.type) {
+            target[index].type = deltaToolCall.type;
+        }
+        if (deltaToolCall?.function?.name) {
+            target[index].function.name += deltaToolCall.function.name;
+        }
+        if (deltaToolCall?.function?.arguments) {
+            target[index].function.arguments +=
+                deltaToolCall.function.arguments;
+        }
+    }
+    normalizeToolCalls(toolCalls) {
+        return toolCalls
+            .filter(Boolean)
+            .map(toolCall => ({
+            id: toolCall.id,
+            type: toolCall.type || 'function',
+            function: {
+                name: toolCall.function?.name || '',
+                arguments: toolCall.function?.arguments || '',
+            },
+        }))
+            .filter(toolCall => toolCall.id ||
+            toolCall.function.name ||
+            toolCall.function.arguments);
+    }
+    // ===================== 错误处理与容错 =====================
+    isModelEngineError(error) {
+        const message = String(error?.message || '').toLowerCase();
+        const status = Number(error?.status || error?.statusCode || 0);
+        const code = String(error?.code || error?.error?.code || '').toLowerCase();
+        return (message.includes('model engine error') ||
+            message.includes('internal server error') ||
+            code.includes('model_engine_error') ||
+            status >= 500);
+    }
+    /**
+     * 判断是否为网络连接错误（ECONNRESET / ETIMEDOUT 等）
+     * 这类错误通常可以通过重试或降级恢复
+     */
+    isNetworkError(error) {
+        const code = String(error?.code || '').toUpperCase();
+        const message = String(error?.message || '').toLowerCase();
+        const networkCodes = new Set([
+            'ECONNRESET',
+            'ETIMEDOUT',
+            'ECONNREFUSED',
+            'ENOTFOUND',
+            'EAI_AGAIN',
+            'EPIPE',
+            'EHOSTUNREACH',
+            'ENETUNREACH',
+        ]);
+        return (networkCodes.has(code) ||
+            message.includes('socket hang up') ||
+            message.includes('network error') ||
+            message.includes('fetch failed') ||
+            message.includes('aborted'));
+    }
+    /**
+     * 判断是否为可恢复错误（模型引擎错误 + 网络错误）
+     * 可恢复错误会触发降级/重试，而非直接抛出
+     */
+    isRecoverableError(error) {
+        return this.isModelEngineError(error) || this.isNetworkError(error);
+    }
+    logModelError(scope, error) {
+        console.error(`[OpenAI] ${scope} 失败:`, {
+            message: error?.message,
+            status: error?.status || error?.statusCode,
+            code: error?.code || error?.error?.code,
+            type: error?.type || error?.error?.type,
+            cause: error?.cause?.message,
+            response: error?.response?.data || error?.error || null,
+        });
+    }
+    getFallbackModels() {
+        const configured = Array.isArray(this.openaiConfig.fallbackModels)
+            ? this.openaiConfig.fallbackModels
+            : [];
+        return Array.from(new Set([...configured, 'glm-5.1', 'deepseek-v3.2', 'kimi-k2.5'].filter(model => !!model && model !== this.openaiConfig.model)));
+    }
+};
+exports.OpenAIService = OpenAIService;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], OpenAIService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Config)('openai'),
+    __metadata("design:type", Object)
+], OpenAIService.prototype, "openaiConfig", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OpenAIService.prototype, "init", null);
+exports.OpenAIService = OpenAIService = __decorate([
+    (0, core_1.Provide)()
+], OpenAIService);

package/dist/service/prompt-builder.service.d.ts

@@ -0,0 +1,50 @@
+import { Context } from '@midwayjs/koa';
+import { AgentProfileService } from './agent-profile.service';
+import { MCPServerService } from './mcp-server.service';
+import { AISkillService } from './ai-skill.service';
+import AIAgentProfileEntity from '../model/ai-agent-profile.entity';
+import type { ToolRegistry, SkillManager } from '@cicctencent/agent-core';
+/**
+ * Prompt 构建服务
+ *
+ * 负责构建 Agent 的系统提示词，包括：
+ * - 基础 Prompt（来自 Agent Profile）
+ * - 工具说明注入
+ * - 记忆上下文
+ * - Skill 上下文
+ */
+export declare class PromptBuilderService {
+    ctx: Context;
+    agentProfileService: AgentProfileService;
+    mcpServerService: MCPServerService;
+    skillService: AISkillService;
+    /**
+     * 构建完整的系统提示词
+     */
+    buildSystemPrompt(applicationId: number, profileId?: number, options?: {
+        includeTools?: boolean;
+        includeSkills?: boolean;
+        includeMemory?: boolean;
+        memoryContext?: string;
+    }): Promise<string>;
+    /**
+     * 构建工具说明部分（使用 agent-server 共享片段）
+     */
+    private buildToolSection;
+    /**
+     * 构建 Skill 上下文部分
+     */
+    private buildSkillSection;
+    /**
+     * 构建默认 Agent 的系统提示词（使用 agent-server 共享片段）
+     */
+    private getDefaultPrompt;
+    /**
+     * 构建 Specialist Agent 的系统提示词（使用 agent-server 共享片段）
+     */
+    buildSpecialistPrompt(profile: AIAgentProfileEntity, toolRegistry?: ToolRegistry, skillManager?: SkillManager): string;
+    /**
+     * 解析工具显示名（delegate_task → "分发任务 → {agentName}"）
+     */
+    resolveToolDisplayName(toolName: string, args: Record<string, unknown>, toolRegistry?: ToolRegistry): string;
+}