@cicctencent/agent-midway 0.1.1

package/README.md

@@ -0,0 +1,280 @@
+# @cicctencent/agent-midway
+
+AI Workstation Core + Framework Adapters — 提供框架无关的 AI 核心能力，并内置 Express、Koa、Next.js、MidwayJS 适配层。
+
+## 架构设计
+
+`@cicctencent/agent-midway` 现在采用三层结构：
+
+| 层级 | 目录 | 说明 |
+|------|------|------|
+| Core | `src/core` | 框架无关的 AI 门面、请求上下文、SSE、服务容器 |
+| Adapters | `src/adapters` | Express、Koa、Next.js、MidwayJS 的挂载入口 |
+| Midway Component | `src/component.ts` | 保留原有 MidwayJS 一行接入能力 |
+
+核心能力通过 `AIServiceRegistry` 注入业务服务，例如 `agent`、`application`、`dataSource` 和自定义服务。适配层只负责请求解析、响应输出、SSE 和路由挂载。
+
+## 快速接入
+
+### 1. 安装依赖
+
+```bash
+pnpm add @cicctencent/agent-midway
+```
+
+### 2. 在 configuration.ts 中引入
+
+```typescript
+import { Configuration, App, MidwayContainer } from '@midwayjs/core';
+import * as busboy from '@midwayjs/busboy';
+import * as orm from '@midwayjs/typeorm';
+import * as staticFile from '@midwayjs/static-file';
+import * as baseMidwayjs from '@cicctencent/midwayjs-base';
+import * as agentMidway from '@cicctencent/agent-midway';  // ← 一行引入
+
+@Configuration({
+    imports: [
+        busboy,
+        staticFile,
+        baseMidwayjs,
+        orm,
+        aiMidway,  // ← 自动注册全部 AI 控制器/服务/实体
+    ],
+    importConfigs: [join(__dirname, './config')],
+})
+export class ContainerLifeCycle {
+    // ...
+}
+```
+
+### 3. 配置（config/config.default.ts）
+
+```typescript
+export default {
+    // ... 其他配置
+
+    // AI Workstation 组件配置
+    aiMidway: {
+        enabled: true,
+        prefix: '/api',
+        dataDir: 'data',
+        features: {
+            agent: true,
+            chat: true,
+            agentProfile: true,
+            application: true,
+            mcpServer: true,
+            modelConfig: true,
+            settings: true,
+            security: true,
+            automation: true,
+            connectors: true,
+            a2a: true,
+            channels: true,
+            observability: true,
+            knowledgeBase: true,
+        },
+    },
+
+    // OpenAI 配置
+    openai: {
+        baseUrl: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
+        apiKey: process.env.OPENAI_API_KEY || '',
+        model: process.env.OPENAI_MODEL || 'deepseek-chat',
+        maxTokens: 16384,
+        temperature: 0.2,
+    },
+};
+```
+
+### 4. 创建数据库表
+
+组件使用以下 TypeORM 实体（自动注册）：
+
+| 表名 | 实体 | 说明 |
+|------|------|------|
+| `t_ai_application` | AIApplicationEntity | AI 应用 |
+| `t_ai_agent_profile` | AIAgentProfileEntity | Agent 配置 |
+| `t_ai_chat_workspace` | AIChatWorkspaceEntity | 聊天工作空间 |
+| `t_ai_chat_thread` | AIChatThreadEntity | 聊天线程 |
+| `t_ai_chat_message` | AIChatMessageEntity | 聊天消息 |
+| `t_ai_mcp_server` | AIMCPServerEntity | MCP 服务器配置 |
+| `t_ai_model_config` | AIModelConfigEntity | 模型配置 |
+| `t_ai_knowledge_base` | AIKnowledgeBaseEntity | 知识库 |
+| `t_ai_kb_document` | AIKBDocumentEntity | 知识库文档 |
+
+### 5. 验证
+
+启动服务后，访问以下 API：
+
+- `GET /api/applications` — 应用列表
+- `GET /api/agent-profiles` — Agent Profile 列表
+- `GET /api/chat/workspaces` — 工作空间列表
+- `GET /api/settings` — 全局设置
+- `GET /api/observability/dashboard` — 可观测性仪表板
+- `GET /.well-known/agent.json` — A2A Agent Card
+
+## 功能模块
+
+| 模块 | 路由前缀 | 说明 |
+|------|---------|------|
+| Agent 运行 | `/api/agent` | 流式/非流式运行、任务队列、abort/regenerate/fork |
+| 聊天管理 | `/api/chat` | 工作空间/线程/消息 CRUD |
+| Agent Profile | `/api/agent-profiles` | Agent 配置管理 |
+| Application | `/api/applications` | 多应用隔离 |
+| MCP Server | `/api/mcp-servers` | MCP 服务器管理 |
+| 模型配置 | `/api/model-configs` | 多模型供应商配置 |
+| 设置 | `/api/settings` | 全局设置 |
+| 安全审计 | `/api/security` | 审计日志、工具风险、权限审批 |
+| 自动化 | `/api/automations` | Cron 定时任务 |
+| 连接器 | `/api/connectors` | 7种数据源适配器 + 工具发现 |
+| A2A 协议 | `/.well-known/agent.json`, `/a2a` | Agent 间互操作 |
+| IM 渠道 | `/api/channels` | 飞书/钉钉/企微 |
+| 可观测性 | `/api/observability` | 链路追踪、指标、仪表板 |
+| 知识库 | `/api/knowledge-bases` | 向量搜索 |
+
+## 多框架适配
+
+### Express
+
+```typescript
+import express from 'express';
+import { mountExpressAI } from '@cicctencent/agent-midway';
+
+const app = express();
+app.use(express.json());
+
+mountExpressAI(app, {
+    prefix: '/api',
+    services: {
+        agent: agentServerService,
+        application: applicationService,
+        dataSource,
+    },
+    resolveUser: req => ({
+        userId: String(req.raw.user?.id || 'anonymous'),
+    }),
+});
+```
+
+### Koa
+
+```typescript
+import Koa from 'koa';
+import bodyParser from 'koa-bodyparser';
+import { mountKoaAI } from '@cicctencent/agent-midway';
+
+const app = new Koa();
+app.use(bodyParser());
+
+mountKoaAI(app, {
+    prefix: '/api',
+    services: {
+        agent: agentServerService,
+        application: applicationService,
+    },
+    resolveUser: ctx => ({
+        userId: String(ctx.raw.state?.user?.id || 'anonymous'),
+    }),
+});
+```
+
+### Next.js App Router
+
+```typescript
+// app/api/ai/[...path]/route.ts
+import { createNextAIHandlers } from '@cicctencent/agent-midway';
+
+const handlers = createNextAIHandlers({
+    prefix: '/api/ai',
+    services: {
+        agent: agentServerService,
+        application: applicationService,
+    },
+    resolveUser: request => ({
+        userId: String(request.headers?.['x-user-id'] || 'anonymous'),
+    }),
+});
+
+export const GET = handlers.GET;
+export const POST = handlers.POST;
+```
+
+### MidwayJS
+
+MidwayJS 继续支持原有组件方式：
+
+```typescript
+import * as agentMidway from '@cicctencent/agent-midway';
+
+@Configuration({
+    imports: [baseMidwayjs, orm, aiMidway],
+})
+export class ContainerLifeCycle {}
+```
+
+也可以在 Midway 服务中使用 `createMidwayAIWorkstation()` 复用框架无关核心能力。
+
+### 已内置路由
+
+| 方法 | 路由 | 说明 |
+|------|------|------|
+| `POST` | `{prefix}/agent/run` | Agent SSE 流式运行 |
+| `POST` | `{prefix}/agent/run/sync` | Agent 同步运行 |
+| `GET` | `{prefix}/agent/reconnect/:threadId` | SSE 断线重连 |
+| `POST` | `{prefix}/agent/abort/:threadId` | 中止 Agent |
+| `GET` | `{prefix}/agent/health` | Agent 健康检查 |
+
+## 按需开关
+
+```typescript
+aiMidway: {
+    features: {
+        // 只用 Agent + Chat，不需要其他功能
+        agent: true,
+        chat: true,
+        agentProfile: true,
+        application: true,
+        mcpServer: false,
+        modelConfig: false,
+        settings: false,
+        security: false,
+        automation: false,
+        connectors: false,
+        a2a: false,
+        channels: false,
+        observability: false,
+        knowledgeBase: false,
+    },
+}
+```
+
+## 自定义扩展
+
+### 覆盖服务
+
+```typescript
+import { Provide } from '@midwayjs/core';
+import { AgentProfileService } from '@cicctencent/agent-midway';
+
+@Provide()
+export class CustomAgentProfileService extends AgentProfileService {
+    async list(applicationId: number) {
+        // 自定义逻辑
+        return super.list(applicationId);
+    }
+}
+```
+
+### 添加自定义工具
+
+```typescript
+import { toolRegistry } from '@cicctencent/agent-midway';
+
+toolRegistry.register({
+    id: 'my_tool',
+    description: 'My custom tool',
+    parameters: { type: 'object', properties: { input: { type: 'string' } } },
+    execute: async (args) => ({ result: args.input }),
+});
+```

package/dist/adapters/express.d.ts

@@ -0,0 +1,8 @@
+import type { AIFrameworkAdapterOptions } from '../core/types';
+export declare function createExpressAIRouter(options: AIFrameworkAdapterOptions): any;
+export declare function mountExpressAI(app: any, options: AIFrameworkAdapterOptions): any;
+export declare function expressAIRoutes(options: AIFrameworkAdapterOptions): {
+    prefix: string;
+    router: any;
+    route(path: string): string;
+};

package/dist/adapters/express.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressAIRouter = createExpressAIRouter;
+exports.mountExpressAI = mountExpressAI;
+exports.expressAIRoutes = expressAIRoutes;
+const ai_workstation_1 = require("../core/ai-workstation");
+const sse_1 = require("../core/sse");
+const shared_1 = require("./shared");
+function createExpressAIRouter(options) {
+    let express;
+    try {
+        express = require('express');
+    }
+    catch {
+        throw new Error('createExpressAIRouter requires express to be installed by the host application.');
+    }
+    const core = (0, ai_workstation_1.createAIWorkstation)(options);
+    const router = express.Router();
+    router.post('/agent/run', async (req, res) => {
+        await core.runAgentStream((0, shared_1.createRequestContext)({
+            method: req.method,
+            path: req.path,
+            query: req.query,
+            params: req.params,
+            body: req.body,
+            headers: req.headers,
+            raw: req,
+        }), (0, sse_1.createNodeSSEWriter)(res));
+    });
+    router.post('/agent/run/sync', async (req, res) => {
+        const result = await core.runAgentSync((0, shared_1.createRequestContext)({
+            method: req.method,
+            path: req.path,
+            query: req.query,
+            params: req.params,
+            body: req.body,
+            headers: req.headers,
+            raw: req,
+        }));
+        (0, shared_1.sendJson)(res, result);
+    });
+    router.get('/agent/reconnect/:threadId', async (req, res) => {
+        await core.reconnectStream((0, shared_1.createRequestContext)({
+            method: req.method,
+            path: req.path,
+            query: req.query,
+            params: req.params,
+            headers: req.headers,
+            raw: req,
+        }), (0, sse_1.createNodeSSEWriter)(res));
+    });
+    router.post('/agent/abort/:threadId', async (req, res) => {
+        const result = await core.abortAgent((0, shared_1.createRequestContext)({
+            method: req.method,
+            path: req.path,
+            query: req.query,
+            params: req.params,
+            body: req.body,
+            headers: req.headers,
+            raw: req,
+        }));
+        (0, shared_1.sendJson)(res, result);
+    });
+    router.get('/agent/health', async (req, res) => {
+        const result = await core.health((0, shared_1.createRequestContext)({
+            method: req.method,
+            path: req.path,
+            query: req.query,
+            headers: req.headers,
+            raw: req,
+        }));
+        (0, shared_1.sendJson)(res, result);
+    });
+    return router;
+}
+function mountExpressAI(app, options) {
+    const core = (0, ai_workstation_1.createAIWorkstation)(options);
+    const router = createExpressAIRouter(options);
+    app.use(core.prefix, router);
+    return router;
+}
+function expressAIRoutes(options) {
+    const core = (0, ai_workstation_1.createAIWorkstation)(options);
+    return {
+        prefix: core.prefix,
+        router: createExpressAIRouter(options),
+        route(path) {
+            return (0, shared_1.joinRoute)(core.prefix, path);
+        },
+    };
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,5 @@
+export * from './shared';
+export * from './express';
+export * from './koa';
+export * from './next';
+export * from './midway';

package/dist/adapters/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./shared"), exports);
+__exportStar(require("./express"), exports);
+__exportStar(require("./koa"), exports);
+__exportStar(require("./next"), exports);
+__exportStar(require("./midway"), exports);

package/dist/adapters/koa.d.ts

@@ -0,0 +1,3 @@
+import type { AIFrameworkAdapterOptions } from '../core/types';
+export declare function createKoaAIMiddleware(options: AIFrameworkAdapterOptions): any;
+export declare function mountKoaAI(app: any, options: AIFrameworkAdapterOptions): any;

package/dist/adapters/koa.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKoaAIMiddleware = createKoaAIMiddleware;
+exports.mountKoaAI = mountKoaAI;
+const ai_workstation_1 = require("../core/ai-workstation");
+const sse_1 = require("../core/sse");
+const shared_1 = require("./shared");
+function matchPath(pattern, path) {
+    const patternParts = pattern.split('/').filter(Boolean);
+    const pathParts = path.split('/').filter(Boolean);
+    if (patternParts.length !== pathParts.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < patternParts.length; i++) {
+        const expected = patternParts[i];
+        const actual = pathParts[i];
+        if (expected.startsWith(':'))
+            params[expected.slice(1)] = actual;
+        else if (expected !== actual)
+            return null;
+    }
+    return params;
+}
+function createKoaAIMiddleware(options) {
+    const core = (0, ai_workstation_1.createAIWorkstation)(options);
+    const routes = [
+        { method: 'POST', path: `${core.prefix}/agent/run`, type: 'stream' },
+        { method: 'POST', path: `${core.prefix}/agent/run/sync`, type: 'sync' },
+        { method: 'GET', path: `${core.prefix}/agent/reconnect/:threadId`, type: 'reconnect' },
+        { method: 'POST', path: `${core.prefix}/agent/abort/:threadId`, type: 'abort' },
+        { method: 'GET', path: `${core.prefix}/agent/health`, type: 'health' },
+    ];
+    return async function aiKoaMiddleware(ctx, next) {
+        const route = routes
+            .map(item => ({ ...item, params: matchPath(item.path, ctx.path) }))
+            .find(item => item.method === ctx.method && item.params);
+        if (!route)
+            return next();
+        const requestContext = (0, shared_1.createRequestContext)({
+            method: ctx.method,
+            path: ctx.path,
+            query: ctx.query,
+            params: route.params || {},
+            body: ctx.request?.body,
+            headers: ctx.headers,
+            raw: ctx,
+        });
+        if (route.type === 'stream') {
+            ctx.respond = false;
+            await core.runAgentStream(requestContext, (0, sse_1.createNodeSSEWriter)(ctx.res));
+            return;
+        }
+        if (route.type === 'reconnect') {
+            ctx.respond = false;
+            await core.reconnectStream(requestContext, (0, sse_1.createNodeSSEWriter)(ctx.res));
+            return;
+        }
+        const result = route.type === 'sync'
+            ? await core.runAgentSync(requestContext)
+            : route.type === 'abort'
+                ? await core.abortAgent(requestContext)
+                : await core.health(requestContext);
+        if (ctx.body !== undefined || typeof ctx.set === 'function') {
+            ctx.body = result;
+        }
+        else {
+            (0, shared_1.sendJson)(ctx.res, result);
+        }
+    };
+}
+function mountKoaAI(app, options) {
+    const middleware = createKoaAIMiddleware(options);
+    app.use(middleware);
+    return middleware;
+}

package/dist/adapters/midway.d.ts

@@ -0,0 +1,5 @@
+import type { AIFrameworkAdapterOptions } from '../core/types';
+import { AIWorkstationComponent } from '../component';
+export { AIWorkstationComponent };
+export declare function createMidwayAIWorkstation(options: AIFrameworkAdapterOptions): import("../core/ai-workstation").AIWorkstationCore;
+export declare const midwayAIComponent: typeof AIWorkstationComponent;

package/dist/adapters/midway.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.midwayAIComponent = exports.AIWorkstationComponent = void 0;
+exports.createMidwayAIWorkstation = createMidwayAIWorkstation;
+const ai_workstation_1 = require("../core/ai-workstation");
+const component_1 = require("../component");
+Object.defineProperty(exports, "AIWorkstationComponent", { enumerable: true, get: function () { return component_1.AIWorkstationComponent; } });
+function createMidwayAIWorkstation(options) {
+    return (0, ai_workstation_1.createAIWorkstation)(options);
+}
+exports.midwayAIComponent = component_1.AIWorkstationComponent;

package/dist/adapters/next.d.ts

@@ -0,0 +1,12 @@
+import type { AIFrameworkAdapterOptions } from '../core/types';
+export declare function createNextAIHandlers(options: AIFrameworkAdapterOptions): {
+    GET: (request: Request, context?: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    POST: (request: Request, context?: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    handle: (request: Request, context?: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+};

package/dist/adapters/next.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNextAIHandlers = createNextAIHandlers;
+const ai_workstation_1 = require("../core/ai-workstation");
+const shared_1 = require("./shared");
+class WebResponseSSEWriter {
+    constructor() {
+        this.encoder = new TextEncoder();
+        this.ended = false;
+        this.stream = new ReadableStream({
+            start: controller => {
+                this.controller = controller;
+            },
+        });
+    }
+    get writableEnded() {
+        return this.ended;
+    }
+    setHeader(_name, _value) { }
+    flushHeaders() { }
+    write(data) {
+        if (this.ended)
+            return;
+        this.controller?.enqueue(this.encoder.encode(data));
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.controller?.close();
+    }
+}
+function createNextAIHandlers(options) {
+    const core = (0, ai_workstation_1.createAIWorkstation)(options);
+    async function handle(request, context) {
+        const url = new URL(request.url);
+        const path = url.pathname;
+        const relativePath = path.startsWith(core.prefix) ? path.slice(core.prefix.length) || '/' : path;
+        const body = request.method === 'GET' ? undefined : await readJsonBody(request);
+        const requestContext = (0, shared_1.createRequestContext)({
+            method: request.method,
+            path,
+            query: Object.fromEntries(url.searchParams.entries()),
+            params: context?.params || {},
+            body,
+            headers: Object.fromEntries(request.headers.entries()),
+            raw: request,
+        });
+        if (request.method === 'POST' && relativePath === '/agent/run') {
+            const writer = new WebResponseSSEWriter();
+            core.runAgentStream(requestContext, writer).catch(error => {
+                writer.write(`data: ${JSON.stringify({ type: 'error', data: { message: error.message }, timestamp: Date.now() })}\n\n`);
+                writer.end();
+            });
+            return new Response(writer.stream, {
+                headers: {
+                    'Content-Type': 'text/event-stream; charset=utf-8',
+                    'Cache-Control': 'no-cache, no-transform',
+                    'Connection': 'keep-alive',
+                    'X-Accel-Buffering': 'no',
+                },
+            });
+        }
+        const result = request.method === 'POST' && relativePath === '/agent/run/sync'
+            ? await core.runAgentSync(requestContext)
+            : request.method === 'POST' && relativePath.startsWith('/agent/abort')
+                ? await core.abortAgent(requestContext)
+                : request.method === 'GET' && relativePath === '/agent/health'
+                    ? await core.health(requestContext)
+                    : { ret: 1, msg: `Unsupported AI route: ${request.method} ${relativePath}` };
+        return Response.json(result);
+    }
+    return {
+        GET: handle,
+        POST: handle,
+        handle,
+    };
+}
+async function readJsonBody(request) {
+    const text = await request.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/adapters/shared.d.ts

@@ -0,0 +1,4 @@
+import type { AIRequestContext } from '../core/types';
+export declare function joinRoute(prefix: string, path: string): string;
+export declare function createRequestContext(input: Partial<AIRequestContext>): AIRequestContext;
+export declare function sendJson(res: any, payload: any): void;

package/dist/adapters/shared.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinRoute = joinRoute;
+exports.createRequestContext = createRequestContext;
+exports.sendJson = sendJson;
+function joinRoute(prefix, path) {
+    const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    const cleanPath = path.startsWith('/') ? path : `/${path}`;
+    return `${cleanPrefix}${cleanPath}`;
+}
+function createRequestContext(input) {
+    return {
+        method: input.method || 'GET',
+        path: input.path || '/',
+        query: input.query || {},
+        params: input.params || {},
+        body: input.body,
+        headers: input.headers || {},
+        raw: input.raw,
+    };
+}
+function sendJson(res, payload) {
+    if (typeof res.json === 'function') {
+        res.json(payload);
+        return;
+    }
+    if (typeof res.setHeader === 'function') {
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    res.end(JSON.stringify(payload));
+}

package/dist/channel/dingtalk.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 钉钉渠道适配器
+ *
+ * 发送消息：调用 https://oapi.dingtalk.com/v1.0/robot/oToMessages/batchSend
+ * 接收消息：解析 {text:{content}, senderStaffId, conversationId}
+ */
+import type { ChannelAdapter, ChannelConfig, ChannelType, ReceivedMessage } from './types';
+export declare class DingTalkAdapter implements ChannelAdapter {
+    readonly type: ChannelType;
+    private config;
+    init(config: ChannelConfig): Promise<void>;
+    /** 获取钉钉 access_token */
+    private getAccessToken;
+    sendMessage(config: ChannelConfig, receiveId: string, message: string): Promise<boolean>;
+    receiveMessage(body: any, _headers?: any): Promise<ReceivedMessage | null>;
+    getConfig(): ChannelConfig;
+    verifySignature(body: any, headers: any, config: ChannelConfig): boolean;
+}