@blocklet/pages-kit-agents 0.5.12

package/lib/cjs/utils/agent-utils.d.ts

@@ -0,0 +1,3 @@
+import { ClaudeChatModel } from '@aigne/core/models/claude-chat-model.js';
+import { OpenAIChatModel } from '@aigne/core/models/openai-chat-model.js';
+export declare function getModel(modelName?: string): OpenAIChatModel | ClaudeChatModel | undefined;

package/lib/cjs/utils/agent-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const claude_chat_model_js_1 = require("@aigne/core/models/claude-chat-model.js");
+const gemini_chat_model_js_1 = require("@aigne/core/models/gemini-chat-model.js");
+const openai_chat_model_js_1 = require("@aigne/core/models/openai-chat-model.js");
+const node_assert_1 = __importDefault(require("node:assert"));
+const { OPENAI_API_KEY, GEMINI_API_KEY, CLAUDE_API_KEY } = process.env;
+function getModel(modelName = 'openai') {
+    if (modelName?.includes('gpt')) {
+        (0, node_assert_1.default)(OPENAI_API_KEY, 'Please set the OPENAI_API_KEY environment variable');
+        const openai = new openai_chat_model_js_1.OpenAIChatModel({
+            apiKey: OPENAI_API_KEY,
+            model: modelName,
+            modelOptions: {
+                temperature: 0.8,
+            },
+        });
+        return openai;
+    }
+    if (modelName?.includes('gemini')) {
+        (0, node_assert_1.default)(GEMINI_API_KEY, 'Please set the GEMINI_API_KEY environment variable');
+        const gemini = new gemini_chat_model_js_1.GeminiChatModel({
+            apiKey: GEMINI_API_KEY,
+            model: modelName,
+        });
+        return gemini;
+    }
+    if (modelName?.includes('claude')) {
+        (0, node_assert_1.default)(CLAUDE_API_KEY, 'Please set the CLAUDE_API_KEY environment variable');
+        const model = new claude_chat_model_js_1.ClaudeChatModel({
+            apiKey: CLAUDE_API_KEY,
+            model: modelName,
+            modelOptions: {
+                temperature: 0.7,
+            },
+        });
+        return model;
+    }
+    return undefined;
+}

package/lib/cjs/utils/file-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Updates the file list JSON by scanning the sample-output directory
+ * and generating a list of all HTML files in each subfolder
+ */
+export declare function updateFileList(): Promise<void>;

package/lib/cjs/utils/file-utils.js

@@ -0,0 +1,90 @@
+"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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateFileList = updateFileList;
+const fs_1 = require("fs");
+const fs = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Updates the file list JSON by scanning the sample-output directory
+ * and generating a list of all HTML files in each subfolder
+ */
+async function updateFileList() {
+    const outputDir = path_1.default.join(process.cwd(), 'sample-output');
+    const indexPath = path_1.default.join(outputDir, 'index.html');
+    // 存储所有子文件夹及其HTML文件信息
+    const fileList = [];
+    try {
+        // 读取sample-output目录下的所有子文件夹
+        const folders = await fs.readdir(outputDir, { withFileTypes: true });
+        // 过滤出目录，并排除特定文件
+        const dirNames = folders
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name)
+            .filter((name) => name !== '.git' && !name.startsWith('.'));
+        // 按照文件夹名称排序（时间戳格式，新的在前）
+        dirNames.sort().reverse();
+        // 处理每个子文件夹
+        for (const folderName of dirNames) {
+            const folderPath = path_1.default.join(outputDir, folderName);
+            // eslint-disable-next-line no-await-in-loop
+            const folderFiles = await fs.readdir(folderPath, { withFileTypes: true });
+            // 过滤出HTML文件
+            const htmlFiles = folderFiles
+                .filter((file) => file.isFile() && file.name.endsWith('.html'))
+                .map((file) => {
+                const fileName = file.name.replace(/\.html$/, '');
+                return {
+                    name: fileName,
+                    path: `${folderName}/${file.name}`,
+                    createdAt: new Date().toISOString(),
+                };
+            });
+            // 将文件夹信息添加到列表
+            fileList.push({
+                folder: folderName,
+                files: htmlFiles,
+            });
+        }
+        // 更新index.html，内联JSON数据
+        if ((0, fs_1.existsSync)(indexPath)) {
+            let indexHtml = await fs.readFile(indexPath, 'utf8');
+            // 使用更简洁的替换方式
+            const fileListPlaceholder = /const FILE_LIST_DATA = .*?;/s;
+            if (fileListPlaceholder.test(indexHtml)) {
+                // 替换占位符为实际数据
+                const jsonString = JSON.stringify(fileList, null, 2);
+                indexHtml = indexHtml.replace(fileListPlaceholder, `const FILE_LIST_DATA = ${jsonString};`);
+                await fs.writeFile(indexPath, indexHtml, 'utf8');
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error updating file list:', error);
+    }
+}

package/lib/cjs/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 读取指定路径的文件并返回字符串内容
+ * @param filePath 文件路径，可以是相对路径或绝对路径
+ * @param encoding 文件编码，默认为 'utf-8'
+ * @returns 文件内容字符串
+ * @throws 如果文件不存在或读取失败则抛出异常
+ */
+export declare function readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
+export * from './agent-utils';
+export * from './logger';
+export * from './template-utils';
+export * from './file-utils';

package/lib/cjs/utils/index.js

@@ -0,0 +1,48 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = readFile;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * 读取指定路径的文件并返回字符串内容
+ * @param filePath 文件路径，可以是相对路径或绝对路径
+ * @param encoding 文件编码，默认为 'utf-8'
+ * @returns 文件内容字符串
+ * @throws 如果文件不存在或读取失败则抛出异常
+ */
+async function readFile(filePath, encoding = 'utf-8') {
+    try {
+        // 如果是相对路径，则从当前工作目录解析
+        const resolvedPath = node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.resolve(process.cwd(), filePath);
+        // 读取文件内容
+        const content = await (0, promises_1.readFile)(resolvedPath, { encoding });
+        return content;
+    }
+    catch (error) {
+        // 捕获并重新抛出异常，添加更明确的错误信息
+        const err = error;
+        throw new Error(`Failed to read file at path ${filePath}: ${err.message}`);
+    }
+}
+// 导出所有模块功能
+__exportStar(require("./agent-utils"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./template-utils"), exports);
+__exportStar(require("./file-utils"), exports);

package/lib/cjs/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: Console;

package/lib/cjs/utils/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.logger = console;

package/lib/cjs/utils/template-utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 根据JSON数据更新HTML模板并保存到指定目录
+ * @param jsonData 需要应用到模板的JSON数据
+ * @param templatePath 模板HTML文件路径，默认为assets目录下的sample.html
+ * @param outputFolder 输出文件夹名称，将在output目录下创建
+ * @param outputFileName 输出HTML文件名称，不包含扩展名
+ * @returns 生成的HTML文件的完整路径
+ * @throws 如果模板文件不存在或无法创建输出目录则抛出异常
+ */
+export declare function generateHtmlFromTemplate({ jsonData, outputFolder, outputFileName, templatePath, }: {
+    jsonData: Record<string, any>;
+    outputFolder: string;
+    outputFileName: string;
+    templatePath?: string;
+}): Promise<string>;
+/**
+ * 保存HTML内容到指定目录
+ * @param htmlContent 要保存的HTML内容
+ * @param outputFolder 输出文件夹路径
+ * @param outputFileName 输出HTML文件名称，不包含扩展名
+ * @returns 生成的HTML文件的完整路径
+ * @throws 如果无法创建输出目录或写入文件则抛出异常
+ */
+export declare function saveHtmlContent({ htmlContent, outputFolder, outputFileName, }: {
+    htmlContent: string;
+    outputFolder: string;
+    outputFileName: string;
+}): Promise<string>;

package/lib/cjs/utils/template-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHtmlFromTemplate = generateHtmlFromTemplate;
+exports.saveHtmlContent = saveHtmlContent;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * 根据JSON数据更新HTML模板并保存到指定目录
+ * @param jsonData 需要应用到模板的JSON数据
+ * @param templatePath 模板HTML文件路径，默认为assets目录下的sample.html
+ * @param outputFolder 输出文件夹名称，将在output目录下创建
+ * @param outputFileName 输出HTML文件名称，不包含扩展名
+ * @returns 生成的HTML文件的完整路径
+ * @throws 如果模板文件不存在或无法创建输出目录则抛出异常
+ */
+async function generateHtmlFromTemplate({ jsonData, outputFolder, outputFileName, templatePath = 'assets/sample2.html', }) {
+    try {
+        // 读取模板文件
+        const resolvedTemplatePath = node_path_1.default.isAbsolute(templatePath)
+            ? templatePath
+            : node_path_1.default.resolve(process.cwd(), templatePath);
+        const templateContent = await (0, promises_1.readFile)(resolvedTemplatePath, { encoding: 'utf-8' });
+        // 将JSON数据转换为字符串
+        const jsonDataString = JSON.stringify(jsonData);
+        // 替换模板中的jsonData变量
+        const updatedContent = templateContent.replace(/const jsonData = \{[\s\S]*?\};/, `const jsonData = ${jsonDataString};`);
+        // 创建输出目录
+        const outputDir = node_path_1.default.resolve(process.cwd(), 'sample-output', outputFolder);
+        // 确保输出目录存在
+        if (!node_fs_1.default.existsSync(outputDir)) {
+            node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+        }
+        // 构建输出文件的完整路径
+        const outputFilePath = node_path_1.default.join(outputDir, `${outputFileName}.html`);
+        // 写入更新后的HTML内容
+        node_fs_1.default.writeFileSync(outputFilePath, updatedContent, 'utf-8');
+        return outputFilePath;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to generate HTML from template: ${err.message}`);
+    }
+}
+/**
+ * 保存HTML内容到指定目录
+ * @param htmlContent 要保存的HTML内容
+ * @param outputFolder 输出文件夹路径
+ * @param outputFileName 输出HTML文件名称，不包含扩展名
+ * @returns 生成的HTML文件的完整路径
+ * @throws 如果无法创建输出目录或写入文件则抛出异常
+ */
+async function saveHtmlContent({ htmlContent, outputFolder, outputFileName, }) {
+    try {
+        // 创建输出目录
+        const outputDir = node_path_1.default.resolve(process.cwd(), 'sample-output', outputFolder);
+        // 确保输出目录存在
+        if (!node_fs_1.default.existsSync(outputDir)) {
+            node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+        }
+        // 构建输出文件的完整路径
+        const outputFilePath = node_path_1.default.join(outputDir, `${outputFileName}.html`);
+        // 写入HTML内容
+        node_fs_1.default.writeFileSync(outputFilePath, htmlContent, 'utf-8');
+        return outputFilePath;
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to save HTML content: ${err.message}`);
+    }
+}

package/lib/esm/agents/multi-agent-page-writer.d.ts

@@ -0,0 +1,48 @@
+import type { z } from 'zod';
+export interface GeneratePageContentInput {
+    context: string;
+    question: string;
+    sectionsRules?: Record<string, string>;
+    locale: string;
+    outputSchema: z.ZodObject<any>;
+    modelName?: string;
+    onProgress?: (params: {
+        sectionName?: string;
+        sectionIndex?: number;
+        totalSections: number;
+        sectionData?: Record<string, any>;
+        eventType?: 'progress' | 'section' | 'structure_start' | 'structure_complete';
+        structureData?: any;
+    }) => void;
+    checkConnection?: () => boolean;
+}
+/**
+ * 多Agent协作生成页面内容
+ *
+ * 工作流程：
+ * 1. 使用页面结构规划Agent分析内容，规划各section内容
+ * 2. 使用结构验证Agent检查规划的完整性和有效性
+ * 3. 如果验证不通过，将反馈提供给规划Agent进行修正
+ * 4. 逐个生成各section内容
+ * 5. 基于所有section内容生成页面元数据
+ * 6. 整合所有内容返回完整页面数据
+ */
+export default function generatePageContentMultiAgent(input: GeneratePageContentInput): Promise<{
+    title: string;
+    description: string;
+    sectionsData: Record<string, any>;
+} | null>;
+/**
+ * 单独生成特定section的内容
+ * 支持独立调用，为特定section重新生成内容
+ */
+export declare function generateSingleSectionContent({ context, question, locale, sectionName, sectionSchema, sectionPlan, existingSections, modelName, }: {
+    context: string;
+    question: string;
+    locale: string;
+    sectionName: string;
+    sectionSchema: any;
+    sectionPlan?: string;
+    existingSections?: Record<string, any>;
+    modelName?: string;
+}): Promise<import("@aigne/core").Message>;

package/lib/esm/agents/multi-agent-page-writer.js

@@ -0,0 +1,199 @@
+import { AIGNE, UserOutputTopic } from '@aigne/core';
+import { zodSchemaToJsonSchema } from '@blocklet/pages-kit-block-studio/zod-utils';
+import { getModel } from '../utils/agent-utils.js';
+import { logger } from '../utils/logger.js';
+import { generatePageMetadataAgent } from './page-metadata-generator.js';
+import { pageStructurePlannerAgent } from './page-structure-planner.js';
+import { pageStructureValidatorAgent } from './page-structure-validator.js';
+import { createSectionContentAgent } from './section-content-generator.js';
+/**
+ * 多Agent协作生成页面内容
+ *
+ * 工作流程：
+ * 1. 使用页面结构规划Agent分析内容，规划各section内容
+ * 2. 使用结构验证Agent检查规划的完整性和有效性
+ * 3. 如果验证不通过，将反馈提供给规划Agent进行修正
+ * 4. 逐个生成各section内容
+ * 5. 基于所有section内容生成页面元数据
+ * 6. 整合所有内容返回完整页面数据
+ */
+export default async function generatePageContentMultiAgent(input) {
+    const { context = '', question = '', locale = '', outputSchema, onProgress, checkConnection, sectionsRules, modelName = 'gpt-4o-mini', } = input;
+    try {
+        logger.info('Starting multi-agent page content generation');
+        // 检查客户端连接状态的辅助函数
+        const isClientConnected = () => {
+            // 如果没有提供检查函数，默认认为客户端仍连接
+            if (!checkConnection)
+                return true;
+            // 否则调用提供的检查函数
+            return checkConnection();
+        };
+        // 1. 从outputSchema提取sectionsData结构
+        const outputSchemaJson = zodSchemaToJsonSchema(outputSchema);
+        const sectionsSchema = outputSchema.shape.sectionsData;
+        const sectionNames = Object.keys(sectionsSchema.shape);
+        // 触发页面结构开始生成事件
+        if (onProgress) {
+            onProgress({
+                totalSections: sectionNames.length,
+                eventType: 'structure_start',
+            });
+        }
+        // 2. 初始页面结构规划
+        logger.info('Planning initial page structure');
+        // 检查客户端是否仍然连接
+        if (!isClientConnected()) {
+            logger.warn('Client disconnected during structure planning, aborting generation');
+            throw new Error('Client disconnected');
+        }
+        let structurePlanMap = {};
+        const model = getModel(modelName);
+        // 3-4 使用反思工作流生成页面结构
+        const planningEngine = new AIGNE({
+            model,
+            agents: [pageStructurePlannerAgent, pageStructureValidatorAgent],
+            limits: {
+                maxAgentInvokes: 20,
+            },
+        });
+        await planningEngine.invoke(pageStructurePlannerAgent, {
+            context,
+            question,
+            locale,
+            initialStructurePlan: Object.entries(sectionsRules || {}).map(([sectionName, sectionContentPlan]) => ({
+                sectionName,
+                sectionContentPlan,
+            })),
+            outputSchema: JSON.stringify(outputSchemaJson),
+            expectedSections: JSON.stringify(sectionNames),
+        });
+        const structurePlanResult = await planningEngine.subscribe(UserOutputTopic);
+        const { structurePlan } = structurePlanResult.message;
+        // const { structurePlan } = structurePlanResult;
+        logger.info('Initial structure plan generated', structurePlan);
+        await planningEngine.shutdown();
+        // 触发页面结构生成成功事件
+        if (onProgress) {
+            onProgress({
+                totalSections: sectionNames.length,
+                eventType: 'structure_complete',
+                structureData: {
+                    structurePlan,
+                },
+            });
+        }
+        structurePlanMap = Object.fromEntries(structurePlan.map((item) => [item.sectionName, item.sectionContentPlan]));
+        const engine = new AIGNE({
+            model,
+        });
+        // 5. 逐个生成各section内容
+        const sectionsData = {};
+        for (let i = 0; i < sectionNames.length; i++) {
+            const sectionName = sectionNames[i];
+            if (!sectionName) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // 每个section生成前检查客户端连接状态
+            if (!isClientConnected()) {
+                logger.warn(`Client disconnected before generating section ${sectionName}, aborting generation`);
+                return null;
+            }
+            logger.info(`Generating content for section: ${sectionName}`);
+            // 通知当前正在处理的section
+            if (onProgress) {
+                onProgress({
+                    sectionName,
+                    sectionIndex: i,
+                    totalSections: sectionNames.length,
+                });
+            }
+            const sectionSchema = sectionsSchema.shape[sectionName];
+            const sectionPlan = structurePlanMap[sectionName] || `Generate content for ${sectionName}`;
+            const sectionContentInput = {
+                context,
+                question,
+                locale,
+                sectionName,
+                sectionSchema,
+                sectionPlan,
+                generatedSections: JSON.stringify(sectionsData), // 传递已生成的sections
+            };
+            // eslint-disable-next-line no-await-in-loop
+            const sectionContentAgent = await createSectionContentAgent(sectionContentInput);
+            // eslint-disable-next-line no-await-in-loop
+            const sectionContent = await engine.invoke(sectionContentAgent, sectionContentInput);
+            sectionsData[sectionName] = sectionContent;
+            logger.info(`Content generated for section: ${sectionName}`);
+            // 通知该section已生成完成
+            if (onProgress) {
+                const sectionDataObj = {};
+                sectionDataObj[sectionName] = sectionContent;
+                onProgress({
+                    sectionName,
+                    sectionIndex: i,
+                    totalSections: sectionNames.length,
+                    sectionData: sectionDataObj,
+                });
+            }
+        }
+        // 6. 生成页面元数据
+        logger.info('Generating page metadata');
+        // 检查客户端是否仍然连接
+        if (!isClientConnected()) {
+            logger.warn('Client disconnected before generating metadata, aborting generation');
+            throw new Error('Client disconnected');
+        }
+        const metadata = await engine.invoke(generatePageMetadataAgent, {
+            context,
+            question,
+            locale,
+            sectionsData: JSON.stringify(sectionsData),
+        });
+        // 7. 组装完整页面数据
+        const result = {
+            title: metadata.title,
+            description: metadata.description,
+            sectionsData,
+        };
+        logger.info('Multi-agent page content generation completed');
+        return result;
+    }
+    catch (error) {
+        logger.error('Error in multi-agent page content generation:', error);
+        throw error;
+    }
+}
+/**
+ * 单独生成特定section的内容
+ * 支持独立调用，为特定section重新生成内容
+ */
+export async function generateSingleSectionContent({ context, question, locale, sectionName, sectionSchema, sectionPlan, existingSections = {}, modelName = 'gpt-4o-mini', }) {
+    try {
+        logger.info(`Starting single section content generation for: ${sectionName}`);
+        const actualSectionPlan = sectionPlan || `Generate content for ${sectionName}`;
+        const sectionContentInput = {
+            context,
+            question,
+            locale,
+            sectionName,
+            sectionSchema,
+            sectionPlan: actualSectionPlan,
+            generatedSections: JSON.stringify(existingSections),
+        };
+        const sectionContentAgent = await createSectionContentAgent(sectionContentInput);
+        const model = getModel(modelName);
+        const engine = new AIGNE({
+            model,
+        });
+        // eslint-disable-next-line no-await-in-loop
+        const sectionContent = await engine.invoke(sectionContentAgent, sectionContentInput);
+        logger.info(`Single section content generated for: ${sectionName}`);
+        return sectionContent;
+    }
+    catch (error) {
+        logger.error(`Error generating content for section ${sectionName}:`, error);
+        throw error;
+    }
+}

package/lib/esm/agents/page-metadata-generator.d.ts

@@ -0,0 +1,10 @@
+import { AIAgent } from '@aigne/core';
+export declare const generatePageMetadataAgent: AIAgent<{
+    context: string;
+    question: string;
+    locale: string;
+    sectionsData: string;
+}, {
+    description: string;
+    title: string;
+}>;

package/lib/esm/agents/page-metadata-generator.js

@@ -0,0 +1,40 @@
+import { AIAgent } from '@aigne/core';
+import { z } from 'zod';
+const prompt = `您是一名专业的SEO和内容编辑专家，擅长创建有吸引力和描述性强的页面元数据。
+
+您的职责
+1. 基于已生成的页面内容，创建准确、吸引人的页面标题
+2. 创建简洁而信息丰富的页面描述，适合在搜索结果和社交媒体分享中显示
+3. 确保标题和描述准确反映页面内容
+4. 优化元数据以提高页面的SEO价值
+
+## 输入上下文:
+{{context}}
+
+## 用户指令:
+{{question}}
+
+## 已生成的页面内容:
+{{sectionsData}}
+
+## 要求
+1. 页面标题：简洁有力，准确描述页面内容，长度在5-10个词之间
+2. 页面描述：提供页面内容的简明概述，长度不超过160个字符
+3. 标题和描述必须基于实际生成的页面内容
+4. 标题和描述应使用 {{locale}} 语言
+
+请为以上页面内容生成合适的标题和描述。`;
+export const generatePageMetadataAgent = AIAgent.from({
+    name: 'Page Metadata Generator',
+    instructions: prompt,
+    inputSchema: z.object({
+        context: z.string(),
+        question: z.string(),
+        locale: z.string(),
+        sectionsData: z.string(),
+    }),
+    outputSchema: z.object({
+        title: z.string().describe('页面标题'),
+        description: z.string().describe('页面描述'),
+    }),
+});