@cicctencent/agent-midway 0.1.1

package/dist/memory/index.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Agent 记忆系统
+ *
+ * 参考 Mastra Memory（https://mastra.ai/docs/memory/overview），
+ * 提供工作记忆（会话上下文）和长期记忆（跨会话知识）。
+ *
+ * 架构分层：
+ * ┌─────────────────────────────────┐
+ * │         AgentMemory             │ ← 统一接口层
+ * │  (buildMemoryContext / recall)  │
+ * ├─────────────────────────────────┤
+ * │      Working Memory             │ ← 当前会话线程的近期记忆
+ * │    (getByThread, save)          │
+ * ├─────────────────────────────────┤
+ * │      Long-term Memory           │ ← 跨会话的持久化知识
+ * │   (search, saveLongTerm)        │
+ * ├─────────────────────────────────┤
+ * │       MemoryStore               │ ← 存储抽象层（可插拔）
+ * │   (InMemoryStore / DB Store)    │
+ * └─────────────────────────────────┘
+ *
+ * 记忆提取策略：
+ * - 用户消息中包含“喜欢/偏好/习惯”等关键词 → 提取为 preference 记忆
+ * - 用户消息中包含事实性表述且长度 > 10 字 → 提取为 fact 记忆
+ * - 每轮对话结束后保存最后一条消息到工作记忆
+ *
+ * 生产环境升级路径：
+ * - 将 InMemoryStore 替换为数据库实现（如 PostgreSQL + pgvector）
+ * - 将关键词匹配搜索升级为向量相似度搜索
+ * - 将规则提取升级为 LLM 提取（调用 LLM 从对话中提取结构化记忆）
+ */
+import type { MemoryEntry, MemoryStore } from '../types';
+import { DataSource } from 'typeorm';
+export { DBMemoryStore } from './db-store';
+/**
+ * 内存记忆存储实现
+ *
+ * 适用于单实例 / 开发环境，数据存储在内存中，重启后丢失。
+ * 生产环境应替换为数据库实现（实现 MemoryStore 接口即可）。
+ *
+ * 搜索算法：
+ * 当前使用简单的关键词匹配 + 分类加权：
+ * - 每个匹配关键词 +1 分
+ * - fact 分类额外 +0.5 分
+ * - preference 分类额外 +0.3 分
+ * - 按总分降序排序，返回 topK 结果
+ */
+export declare class InMemoryStore implements MemoryStore {
+    private entries;
+    save(entry: Omit<MemoryEntry, 'id' | 'createdAt'>): Promise<MemoryEntry>;
+    load(userId: string, options?: {
+        threadId?: number | string;
+        category?: string;
+        limit?: number;
+    }): Promise<MemoryEntry[]>;
+    getByThread(threadId: string | number, limit?: number): Promise<MemoryEntry[]>;
+    getByUser(userId: string, category?: string, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * 搜索相关记忆
+     * 使用关键词匹配 + 分类加权算法，过滤已过期记忆。
+     *
+     * @param userId 用户 ID
+     * @param query 搜索查询（自然语言）
+     * @param topK 返回结果数量，默认 10
+     * @returns 按相关度降序排列的记忆列表
+     */
+    search(userId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
+    delete(id: string | number): Promise<boolean>;
+    clearThread(threadId: string | number): Promise<void>;
+    clear(userId: string): Promise<void>;
+}
+/**
+ * 创建 MemoryStore 实例
+ * 根据环境变量 AGENT_MEMORY_STORE 决定使用内存还是数据库存储。
+ *
+ * @param dataSource TypeORM DataSource（使用 db 存储时必需）
+ * @returns MemoryStore 实例
+ */
+export declare function createMemoryStore(dataSource?: DataSource): MemoryStore;
+/**
+ * Agent 记忆管理器
+ *
+ * 封装工作记忆（当前会话）和长期记忆（跨会话）的统一访问接口。
+ * Agent 在每轮对话前后通过此类注入 / 提取记忆。
+ *
+ * 典型调用流程：
+ * 1. Agent 构建 system prompt 时调用 buildMemoryContext() 注入相关记忆
+ * 2. Agent 对话完成后调用 extractAndSave() 从对话中提取新记忆
+ */
+export declare class AgentMemory {
+    private store;
+    constructor(store?: MemoryStore);
+    /** 获取存储实例 */
+    getStore(): MemoryStore;
+    /**
+     * 保存会话消息到工作记忆
+     * 用于当前会话的上下文保持
+     */
+    saveWorkingMemory(threadId: string, userId: string, content: string, meta?: Record<string, any>): Promise<MemoryEntry>;
+    /**
+     * 获取工作记忆（当前会话的近期记忆）
+     */
+    getWorkingMemory(threadId: string | number, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * 保存长期记忆
+     * 从对话中提取的关键信息，跨会话持久化
+     */
+    saveLongTermMemory(userId: string, content: string, category?: MemoryEntry['category'], meta?: Record<string, any>): Promise<MemoryEntry>;
+    /**
+     * 检索相关记忆
+     * 综合工作记忆（当前线程近期）和长期记忆（语义搜索），去重后按相关度排序。
+     *
+     * @param userId 用户 ID
+     * @param query 搜索查询
+     * @param options.threadId 当前线程 ID（用于加载工作记忆）
+     * @param options.topK 返回数量，默认 10
+     * @param options.includeWorking 是否包含工作记忆，默认 true
+     */
+    recall(userId: string, query: string, options?: {
+        threadId?: string | number;
+        topK?: number;
+        includeWorking?: boolean;
+    }): Promise<MemoryEntry[]>;
+    /**
+     * 从对话内容中提取记忆
+     *
+     * 当前使用简单规则提取（生产环境可升级为 LLM 提取）：
+     * - 包含“喜欢/偏好/习惯/通常/一般/总是” → preference 记忆
+     * - 包含事实性表述且长度 > 10 字 → fact 记忆
+     * - 每轮对话的最后一条消息保存为工作记忆摘要
+     *
+     * @param userId 用户 ID
+     * @param threadId 线程 ID
+     * @param messages 本轮对话的消息列表
+     * @returns 新提取的记忆条目
+     */
+    extractAndSave(userId: string, threadId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>): Promise<MemoryEntry[]>;
+    /**
+     * 构建记忆上下文（注入到系统提示词）
+     *
+     * 检索与当前查询相关的记忆，格式化为 markdown 列表，
+     * Agent 会将此内容拼接到 system prompt 中，使 LLM “记住”之前的对话。
+     *
+     * @param userId 用户 ID
+     * @param query 当前用户输入（用于搜索相关记忆）
+     * @param threadId 当前线程 ID
+     * @returns 格式化后的记忆上下文字符串，无相关记忆时返回空字符串
+     */
+    buildMemoryContext(userId: string, query: string, threadId?: string): Promise<string>;
+    /** 清除线程记忆 */
+    clearThread(threadId: string | number): Promise<void>;
+    /** 删除指定记忆 */
+    delete(id: string | number): Promise<void>;
+    /**
+     * 构建对话历史消息（注入到 Agent messages 中）
+     *
+     * 从工作记忆中加载近期对话摘要，格式化为 user/assistant 交替的消息对，
+     * 让 Agent 能“记住”当前会话之前的对话内容。
+     *
+     * 策略：
+     * - 工作记忆中的 summary 类型条目代表每轮对话的摘要
+     * - 按时间倒序取最近 N 条，反转为正序
+     * - 如果历史轮次过多，将早期轮次压缩为单个摘要
+     *
+     * @param threadId 线程 ID
+     * @param maxTurns 最大历史轮次，默认 8
+     * @returns 对话历史消息数组（role + content）
+     */
+    buildConversationHistory(threadId: string | number, maxTurns?: number): Promise<Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>>;
+    /**
+     * 提取话题标签并存入线程元数据
+     *
+     * 从用户消息中提取关键词作为话题标签，
+     * 跨会话持久化，新会话时可注入到 system prompt。
+     */
+    extractTopicTags(userId: string, content: string): Promise<string[]>;
+    /**
+     * 获取用户的历史话题标签
+     */
+    getTopicTags(userId: string, limit?: number): Promise<string[]>;
+}

package/dist/memory/index.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentMemory = exports.InMemoryStore = exports.DBMemoryStore = void 0;
+exports.createMemoryStore = createMemoryStore;
+const db_store_1 = require("./db-store");
+var db_store_2 = require("./db-store");
+Object.defineProperty(exports, "DBMemoryStore", { enumerable: true, get: function () { return db_store_2.DBMemoryStore; } });
+/** 生成唯一 ID */
+function generateId() {
+    return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * 内存记忆存储实现
+ *
+ * 适用于单实例 / 开发环境，数据存储在内存中，重启后丢失。
+ * 生产环境应替换为数据库实现（实现 MemoryStore 接口即可）。
+ *
+ * 搜索算法：
+ * 当前使用简单的关键词匹配 + 分类加权：
+ * - 每个匹配关键词 +1 分
+ * - fact 分类额外 +0.5 分
+ * - preference 分类额外 +0.3 分
+ * - 按总分降序排序，返回 topK 结果
+ */
+class InMemoryStore {
+    constructor() {
+        this.entries = [];
+    }
+    async save(entry) {
+        const full = {
+            ...entry,
+            id: generateId(),
+            createdAt: Date.now(),
+        };
+        this.entries.push(full);
+        return full;
+    }
+    async load(userId, options) {
+        const limit = options?.limit || 50;
+        return this.entries
+            .filter(e => e.userId === userId &&
+            (!options?.threadId || String(e.threadId) === String(options.threadId)) &&
+            (!options?.category || e.category === options.category) &&
+            (!e.expiresAt || Number(e.expiresAt) > Date.now()))
+            .sort((a, b) => Number(b.createdAt) - Number(a.createdAt))
+            .slice(0, limit);
+    }
+    async getByThread(threadId, limit = 50) {
+        return this.entries
+            .filter(e => String(e.threadId) === String(threadId) &&
+            (!e.expiresAt || Number(e.expiresAt) > Date.now()))
+            .sort((a, b) => Number(b.createdAt) - Number(a.createdAt))
+            .slice(0, limit);
+    }
+    async getByUser(userId, category, limit = 50) {
+        return this.entries
+            .filter(e => e.userId === userId &&
+            (!category || e.category === category) &&
+            (!e.expiresAt || Number(e.expiresAt) > Date.now()))
+            .sort((a, b) => Number(b.createdAt) - Number(a.createdAt))
+            .slice(0, limit);
+    }
+    /**
+     * 搜索相关记忆
+     * 使用关键词匹配 + 分类加权算法，过滤已过期记忆。
+     *
+     * @param userId 用户 ID
+     * @param query 搜索查询（自然语言）
+     * @param topK 返回结果数量，默认 10
+     * @returns 按相关度降序排列的记忆列表
+     */
+    async search(userId, query, topK = 10) {
+        const queryLower = query.toLowerCase();
+        const scored = this.entries
+            .filter(e => e.userId === userId &&
+            (!e.expiresAt || Number(e.expiresAt) > Date.now()))
+            .map(e => {
+            const contentLower = e.content.toLowerCase();
+            // 简单的关键词匹配评分
+            const words = queryLower.split(/\s+/).filter(w => w.length > 1);
+            let score = 0;
+            for (const word of words) {
+                if (contentLower.includes(word))
+                    score += 1;
+            }
+            // 分类加权
+            if (e.category === 'fact')
+                score += 0.5;
+            if (e.category === 'preference')
+                score += 0.3;
+            return { entry: e, score };
+        })
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+        return scored.map(s => ({ ...s.entry, relevance: s.score }));
+    }
+    async delete(id) {
+        const idStr = String(id);
+        const before = this.entries.length;
+        this.entries = this.entries.filter(e => String(e.id) !== idStr);
+        return this.entries.length < before;
+    }
+    async clearThread(threadId) {
+        this.entries = this.entries.filter(e => String(e.threadId) !== String(threadId));
+    }
+    async clear(userId) {
+        this.entries = this.entries.filter(e => e.userId !== userId);
+    }
+}
+exports.InMemoryStore = InMemoryStore;
+/**
+ * 创建 MemoryStore 实例
+ * 根据环境变量 AGENT_MEMORY_STORE 决定使用内存还是数据库存储。
+ *
+ * @param dataSource TypeORM DataSource（使用 db 存储时必需）
+ * @returns MemoryStore 实例
+ */
+function createMemoryStore(dataSource) {
+    const storeType = process.env.AGENT_MEMORY_STORE || 'memory';
+    if (storeType === 'db') {
+        if (!dataSource) {
+            throw new Error('[MemoryStore] AGENT_MEMORY_STORE=db 时需要传入 DataSource。请通过 InjectDataSource 注入后传入。');
+        }
+        console.log('[MemoryStore] 使用 DBMemoryStore（数据库存储）');
+        return new db_store_1.DBMemoryStore(dataSource);
+    }
+    console.log('[MemoryStore] 使用 InMemoryStore（内存存储）');
+    return new InMemoryStore();
+}
+/**
+ * Agent 记忆管理器
+ *
+ * 封装工作记忆（当前会话）和长期记忆（跨会话）的统一访问接口。
+ * Agent 在每轮对话前后通过此类注入 / 提取记忆。
+ *
+ * 典型调用流程：
+ * 1. Agent 构建 system prompt 时调用 buildMemoryContext() 注入相关记忆
+ * 2. Agent 对话完成后调用 extractAndSave() 从对话中提取新记忆
+ */
+class AgentMemory {
+    constructor(store) {
+        this.store = store || new InMemoryStore();
+    }
+    /** 获取存储实例 */
+    getStore() {
+        return this.store;
+    }
+    /**
+     * 保存会话消息到工作记忆
+     * 用于当前会话的上下文保持
+     */
+    async saveWorkingMemory(threadId, userId, content, meta) {
+        return this.store.save({
+            threadId,
+            userId,
+            content,
+            category: 'summary',
+            meta,
+        });
+    }
+    /**
+     * 获取工作记忆（当前会话的近期记忆）
+     */
+    async getWorkingMemory(threadId, limit = 20) {
+        return this.store.getByThread?.(threadId, limit) ?? [];
+    }
+    /**
+     * 保存长期记忆
+     * 从对话中提取的关键信息，跨会话持久化
+     */
+    async saveLongTermMemory(userId, content, category = 'fact', meta) {
+        return this.store.save({
+            threadId: '__long_term__',
+            userId,
+            content,
+            category,
+            meta,
+        });
+    }
+    /**
+     * 检索相关记忆
+     * 综合工作记忆（当前线程近期）和长期记忆（语义搜索），去重后按相关度排序。
+     *
+     * @param userId 用户 ID
+     * @param query 搜索查询
+     * @param options.threadId 当前线程 ID（用于加载工作记忆）
+     * @param options.topK 返回数量，默认 10
+     * @param options.includeWorking 是否包含工作记忆，默认 true
+     */
+    async recall(userId, query, options) {
+        const topK = options?.topK || 10;
+        const results = [];
+        // 长期记忆搜索
+        const longTerm = await this.store.search?.(userId, query, topK) ?? [];
+        results.push(...longTerm);
+        // 工作记忆（当前线程近期消息）
+        if (options?.includeWorking !== false && options?.threadId) {
+            const working = await this.store.getByThread?.(options.threadId, Math.min(topK, 10)) ?? [];
+            results.push(...working);
+        }
+        // 去重并按相关度排序
+        const seen = new Set();
+        return results
+            .filter(e => {
+            if (seen.has(String(e.id)))
+                return false;
+            seen.add(String(e.id));
+            return true;
+        })
+            .sort((a, b) => (b.relevance || 0) - (a.relevance || 0))
+            .slice(0, topK);
+    }
+    /**
+     * 从对话内容中提取记忆
+     *
+     * 当前使用简单规则提取（生产环境可升级为 LLM 提取）：
+     * - 包含“喜欢/偏好/习惯/通常/一般/总是” → preference 记忆
+     * - 包含事实性表述且长度 > 10 字 → fact 记忆
+     * - 每轮对话的最后一条消息保存为工作记忆摘要
+     *
+     * @param userId 用户 ID
+     * @param threadId 线程 ID
+     * @param messages 本轮对话的消息列表
+     * @returns 新提取的记忆条目
+     */
+    async extractAndSave(userId, threadId, messages) {
+        const saved = [];
+        for (const msg of messages) {
+            if (msg.role !== 'user')
+                continue;
+            const content = msg.content.trim();
+            if (!content || content.length < 5)
+                continue;
+            // 提取偏好信息
+            if (/喜欢|偏好|习惯|通常|一般|总是/i.test(content)) {
+                const entry = await this.saveLongTermMemory(userId, content, 'preference', { source: 'auto_extract' });
+                saved.push(entry);
+            }
+            // 提取事实信息
+            else if (/是|有|在|了|的/.test(content) && content.length > 10) {
+                const entry = await this.saveLongTermMemory(userId, content, 'fact', { source: 'auto_extract' });
+                saved.push(entry);
+            }
+        }
+        // 保存会话摘要到工作记忆（包含原始 user + assistant 对，以便重建对话历史）
+        if (messages.length > 0) {
+            const userMsgs = messages.filter(m => m.role === 'user');
+            const assistantMsgs = messages.filter(m => m.role === 'assistant');
+            const lastUser = userMsgs[userMsgs.length - 1];
+            const lastAssistant = assistantMsgs[assistantMsgs.length - 1];
+            await this.saveWorkingMemory(threadId, userId, lastAssistant?.content || lastUser?.content || '', {
+                messageCount: messages.length,
+                userContent: lastUser?.content || '',
+                assistantContent: lastAssistant?.content || '',
+            });
+        }
+        return saved;
+    }
+    /**
+     * 构建记忆上下文（注入到系统提示词）
+     *
+     * 检索与当前查询相关的记忆，格式化为 markdown 列表，
+     * Agent 会将此内容拼接到 system prompt 中，使 LLM “记住”之前的对话。
+     *
+     * @param userId 用户 ID
+     * @param query 当前用户输入（用于搜索相关记忆）
+     * @param threadId 当前线程 ID
+     * @returns 格式化后的记忆上下文字符串，无相关记忆时返回空字符串
+     */
+    async buildMemoryContext(userId, query, threadId) {
+        const memories = await this.recall(userId, query, {
+            threadId,
+            topK: 5,
+        });
+        if (!memories.length)
+            return '';
+        const lines = ['## 相关记忆'];
+        for (const mem of memories) {
+            const categoryLabel = {
+                fact: '事实',
+                preference: '偏好',
+                summary: '摘要',
+                entity: '实体',
+                task: '任务',
+            }[mem.category] || mem.category;
+            lines.push(`- [${categoryLabel}] ${mem.content}`);
+        }
+        return lines.join('\n');
+    }
+    /** 清除线程记忆 */
+    async clearThread(threadId) {
+        return this.store.clearThread?.(threadId);
+    }
+    /** 删除指定记忆 */
+    async delete(id) {
+        await this.store.delete(id);
+    }
+    /**
+     * 构建对话历史消息（注入到 Agent messages 中）
+     *
+     * 从工作记忆中加载近期对话摘要，格式化为 user/assistant 交替的消息对，
+     * 让 Agent 能“记住”当前会话之前的对话内容。
+     *
+     * 策略：
+     * - 工作记忆中的 summary 类型条目代表每轮对话的摘要
+     * - 按时间倒序取最近 N 条，反转为正序
+     * - 如果历史轮次过多，将早期轮次压缩为单个摘要
+     *
+     * @param threadId 线程 ID
+     * @param maxTurns 最大历史轮次，默认 8
+     * @returns 对话历史消息数组（role + content）
+     */
+    async buildConversationHistory(threadId, maxTurns = 8) {
+        const entries = await this.store.getByThread?.(threadId, maxTurns * 2) ?? [];
+        if (!entries.length)
+            return [];
+        // 筛选 summary 类型的摘要条目（每轮对话保存一条）
+        const summaries = entries
+            .filter(e => e.category === 'summary')
+            .sort((a, b) => Number(a.createdAt) - Number(b.createdAt));
+        if (!summaries.length)
+            return [];
+        // 如果轮次超过上限，将早期轮次压缩为单个摘要
+        const MAX_SUMMARIES = maxTurns;
+        const history = [];
+        if (summaries.length > MAX_SUMMARIES) {
+            // 早期摘要拼接为单条系统消息
+            const earlySummaries = summaries.slice(0, summaries.length - MAX_SUMMARIES);
+            const compressed = earlySummaries.map(s => s.content).join('\n');
+            history.push({
+                role: 'user',
+                content: `[早期对话摘要]\n${compressed}`,
+            });
+            history.push({
+                role: 'assistant',
+                content: '好的，我已了解早期对话的内容。',
+            });
+            // 保留最近的轮次
+            const recentSummaries = summaries.slice(summaries.length - MAX_SUMMARIES);
+            for (const s of recentSummaries) {
+                const content = s.content;
+                const meta = s.meta;
+                // meta 中存储了原始的 user + assistant 对
+                if (meta?.userContent) {
+                    history.push({
+                        role: 'user',
+                        content: String(meta.userContent).slice(0, 500),
+                    });
+                }
+                if (meta?.assistantContent) {
+                    history.push({
+                        role: 'assistant',
+                        content: String(meta.assistantContent).slice(0, 1000),
+                    });
+                }
+                else {
+                    history.push({
+                        role: 'assistant',
+                        content: content.slice(0, 500),
+                    });
+                }
+            }
+        }
+        else {
+            // 轮次不多，直接展开
+            for (const s of summaries) {
+                const meta = s.meta;
+                if (meta?.userContent) {
+                    history.push({
+                        role: 'user',
+                        content: String(meta.userContent).slice(0, 500),
+                    });
+                }
+                if (meta?.assistantContent) {
+                    history.push({
+                        role: 'assistant',
+                        content: String(meta.assistantContent).slice(0, 1000),
+                    });
+                }
+                else {
+                    // 仅摘要，拼接为单条
+                    history.push({
+                        role: 'user',
+                        content: s.content.slice(0, 500),
+                    });
+                    history.push({
+                        role: 'assistant',
+                        content: '已处理该请求。',
+                    });
+                }
+            }
+        }
+        return history;
+    }
+    /**
+     * 提取话题标签并存入线程元数据
+     *
+     * 从用户消息中提取关键词作为话题标签，
+     * 跨会话持久化，新会话时可注入到 system prompt。
+     */
+    async extractTopicTags(userId, content) {
+        const tags = [];
+        // 简单的关键词提取规则（生产环境可升级为 LLM 提取）
+        const patterns = [
+            /(?:分析|查看|对比|统计)(.{2,8})/g,
+            /(?:营收|利润|成本|收入|支出|毛利|净利)/g,
+            /(?:趋势|变化|走势|增长|下降)/g,
+            /(?:产品|客户|地区|部门|渠道)/g,
+        ];
+        for (const p of patterns) {
+            const matches = content.matchAll(p);
+            for (const m of matches) {
+                const tag = (m[1] || m[0]).trim();
+                if (tag.length >= 2 && tag.length <= 8 && !tags.includes(tag)) {
+                    tags.push(tag);
+                }
+            }
+        }
+        // 保存为长期记忆（category: entity）
+        for (const tag of tags.slice(0, 5)) {
+            await this.store.save({
+                threadId: '__topics__',
+                userId,
+                content: tag,
+                category: 'entity',
+                meta: { source: 'topic_extract' },
+            });
+        }
+        return tags;
+    }
+    /**
+     * 获取用户的历史话题标签
+     */
+    async getTopicTags(userId, limit = 20) {
+        const entries = await this.store.getByUser(userId, 'entity', limit);
+        return entries
+            .filter(e => e.threadId === '__topics__')
+            .map(e => e.content)
+            .slice(0, limit);
+    }
+}
+exports.AgentMemory = AgentMemory;

package/dist/model/ai-agent-profile.entity.d.ts

@@ -0,0 +1,32 @@
+import BaseEntity from '@fefeding/common/dist/models/base/baseORM';
+/**
+ * Agent Profile 实体
+ * @table t_agent_profile
+ */
+export default class AIAgentProfileEntity extends BaseEntity {
+    id: number;
+    applicationId: number;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    basePrompt: string;
+    model: string;
+    modelConfigId: string;
+    maxIterations: number;
+    maxMessages: number;
+    toolTimeout: number;
+    disabledTools: string[] | null;
+    mcpServers: (number | string)[] | null;
+    selectedSkills: string[] | null;
+    alwaysInjectSkills: string[] | null;
+    connectorIds: string[] | null;
+    isDefault: number;
+    agentType: string;
+    domain: string;
+    remoteUrl: string;
+    remoteCard: any | null;
+    remoteAuth: any | null;
+    a2aProtocol: string;
+    restA2AConfig: any | null;
+}