@blocklet/pages-kit-agents 0.5.47 → 0.5.48

package/lib/esm/agents/orchestrator/orchestrator-prompts.js

@@ -0,0 +1,131 @@
+import { ensureZodUnionArray } from '@aigne/core/utils/json-schema.js';
+import { duplicates } from '@aigne/core/utils/type-utils.js';
+import { z } from 'zod';
+/**
+ * @hidden
+ */
+export const SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = `\
+Synthesize the results of executing all steps in the plan into a cohesive result
+`;
+/**
+ * @hidden
+ */
+export function getFullPlanSchema(agents) {
+    const agentNames = agents.map((i) => i.name);
+    if (new Set(agentNames).size !== agentNames.length) {
+        const dup = duplicates(agentNames);
+        throw new Error(`Duplicate agent names found in orchestrator: ${dup.join(',')}`);
+    }
+    const TaskSchema = z.object({
+        description: z.string().describe('Detailed description of the task'),
+        agent: z
+            .union(ensureZodUnionArray(agents.map((i) => z.literal(i.name))))
+            .describe('Name of the agent to execute the task'),
+    });
+    const StepSchema = z.object({
+        description: z.string().describe('Detailed description of the step'),
+        tasks: z.array(TaskSchema).describe('Tasks that can run in parallel in this step'),
+    });
+    return z.object({
+        steps: z.array(StepSchema).describe('All sequential steps in the plan'),
+        isComplete: z.boolean().describe('Whether the previous plan results achieve the objective'),
+    });
+}
+/**
+ * @hidden
+ */
+export const FULL_PLAN_PROMPT_TEMPLATE = `You are tasked with orchestrating a plan to complete an objective.
+You can analyze results from the previous steps already executed to decide if the objective is complete.
+Your plan must be structured in sequential steps, with each step containing independent parallel subtasks.
+
+<objective>
+{{objective}}
+</objective>
+
+<steps_completed>
+{{#steps}}
+- Step: {{step.description}}
+  Result: {{result}}
+{{/steps}}
+</steps_completed>
+
+<previous_plan_status>
+{{plan.status}}
+</previous_plan_status>
+
+<previous_plan_result>
+{{plan.result}}
+</previous_plan_result>
+
+You have access to the following Agents(which are collections of tools/functions):
+
+<agents>
+{{#agents}}
+- Agent: {{name}}
+  Description: {{description}}
+  Functions:
+    {{#tools}}
+    - Tool: {{name}}
+      Description: {{description}}
+    {{/tools}}
+{{/agents}}
+</agents>
+
+- If the previous plan results achieve the objective, return isComplete=true.
+- Otherwise, generate remaining steps needed.
+- Generate a plan with all remaining steps needed.
+- Steps are sequential, but each Step can have parallel subtasks.
+- For each Step, specify a description of the step and independent subtasks that can run in parallel.
+- For each subtask specify:
+    1. Clear description of the task that an LLM can execute
+    2. Name of 1 Agent to use for the task`;
+/**
+ * @hidden
+ */
+export const TASK_PROMPT_TEMPLATE = `\
+You are part of a larger workflow to achieve the step then the objective:
+
+<objective>
+{{objective}}
+</objective>
+
+<step>
+{{step.description}}
+</step>
+
+Your job is to accomplish only the following task:
+
+<task>
+{{task.description}}
+</task>
+
+Results so far that may provide helpful context:
+
+<steps_completed>
+{{#steps}}
+- Step: {{step.description}}
+  Result: {{result}}
+{{/steps}}
+</steps_completed>
+`;
+/**
+ * @hidden
+ */
+export const SYNTHESIZE_STEP_PROMPT_TEMPLATE = `\
+Synthesize the results of these parallel tasks into a cohesive result
+
+<objective>
+{{objective}}
+</objective>
+
+<step>
+{{step.description}}
+</step>
+
+<tasks>
+{{#tasks}}
+- Task: {{task.description}}
+  Result: {{result}}
+{{/tasks}}
+</tasks>
+`;

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

@@ -5,6 +5,6 @@ export declare const generatePageMetadataAgent: AIAgent<{
     locale: string;
     sectionsData: string;
 }, {
-    title: string;
     description: string;
+    title: string;
 }>;

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

@@ -1,12 +1,13 @@
 import { AIAgent } from '@aigne/core';
 import { z } from 'zod';
+// import { getMemory } from '../utils';
 const prompt = `您是一名专业的SEO和内容编辑专家，擅长创建有吸引力和描述性强的页面元数据。
 
 您的职责
 1. 基于已生成的页面内容，创建准确、吸引人的页面标题
 2. 创建简洁而信息丰富的页面描述，适合在搜索结果和社交媒体分享中显示
 3. 确保标题和描述准确反映页面内容
-4. 优化元数据以提高页面的SEO价值
+4. 优化元数据以提高页面的 SEO 价值
 
 ## 输入上下文:
 {{context}}
@@ -24,6 +25,7 @@ const prompt = `您是一名专业的SEO和内容编辑专家，擅长创建有
 4. 标题和描述应使用 {{locale}} 语言
 
 请为以上页面内容生成合适的标题和描述。`;
+// const memory = getMemory({ autoUpdate: false });
 export const generatePageMetadataAgent = AIAgent.from({
     name: 'Page Metadata Generator',
     instructions: prompt,
@@ -37,4 +39,5 @@ export const generatePageMetadataAgent = AIAgent.from({
         title: z.string().describe('页面标题'),
         description: z.string().describe('页面描述'),
     }),
+    // memory,
 });

package/lib/esm/agents/page-structure-planner.d.ts

@@ -1,43 +1,70 @@
 import { AIAgent } from '@aigne/core';
-export interface PlanPageStructureInput {
+import { z } from 'zod';
+import { ReflectionAgent } from '../workflow-agents/reflection-agent.js';
+export declare const plannerParamsSchema: z.ZodObject<{
+    context: z.ZodString;
+    question: z.ZodString;
+    locale: z.ZodString;
+    outputSchema: z.ZodString;
+    expectedSections: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    outputSchema: string;
+    context: string;
+    question: string;
+    locale: string;
+    expectedSections: string;
+}, {
+    outputSchema: string;
     context: string;
     question: string;
-    initialStructurePlan?: Array<{
+    locale: string;
+    expectedSections: string;
+}>;
+export interface PageStructurePlannerOutput {
+    structurePlan: Array<{
         sectionName: string;
         sectionContentPlan: string;
     }>;
+}
+export declare const pageStructurePlannerWithReflection: ReflectionAgent<{
+    outputSchema: string;
+    context: string;
+    question: string;
     locale: string;
-    outputSchema: any;
+    expectedSections: string;
     validationFeedback?: {
         isValid: boolean;
         missingSections: string[];
-        duplicateContent: Array<{
-            sections: string[];
+        duplicateContent: {
             description: string;
-        }>;
-        feedback: Array<{
-            sectionName: string;
-            feedback: string;
-        }>;
-        generalFeedback: string;
-    };
-}
-export interface PageStructurePlannerOutput {
-    structurePlan: Array<{
+            sections: string[];
+            score: number;
+            suggestion: string;
+        }[];
+    } | undefined;
+    structurePlan?: {
         sectionName: string;
         sectionContentPlan: string;
-    }>;
-}
+    }[] | undefined;
+}, {
+    isApproved: boolean;
+    validationFeedback: {
+        isValid: boolean;
+        missingSections: string[];
+        duplicateContent: {
+            description: string;
+            sections: string[];
+            score: number;
+            suggestion: string;
+        }[];
+    };
+}>;
 export declare const pageStructurePlannerAgent: AIAgent<{
+    outputSchema: string;
     context: string;
     question: string;
     locale: string;
-    outputSchema: string;
     expectedSections: string;
-    initialStructurePlan: {
-        sectionName: string;
-        sectionContentPlan: string;
-    }[];
     validationFeedback?: {
         isValid: boolean;
         missingSections: string[];
@@ -45,9 +72,19 @@ export declare const pageStructurePlannerAgent: AIAgent<{
             description: string;
             sections: string[];
             score: number;
+            suggestion: string;
         }[];
     } | undefined;
+    structurePlan?: {
+        sectionName: string;
+        sectionContentPlan: string;
+    }[] | undefined;
 }, {
+    outputSchema: string;
+    context: string;
+    question: string;
+    locale: string;
+    expectedSections: string;
     structurePlan: {
         sectionName: string;
         sectionContentPlan: string;

package/lib/esm/agents/page-structure-planner.js

@@ -1,97 +1,124 @@
-import { AIAgent, UserInputTopic } from '@aigne/core';
+import { AIAgent } from '@aigne/core';
+import fs from 'node:fs';
+import path from 'node:path';
 import { z } from 'zod';
-import { logger } from '../utils/logger.js';
-/**
- * 页面结构规划
- * 基于上下文和输出模式，规划各section显示的内容
- * 支持根据验证反馈修改方案
- */
-const prompt = `您是一名有着丰富经验且富有创意的页面结构规划师，擅长分析并规划产品站点的内容结构。
-
-您的职责
-1. 分析用户提供的上下文信息，理解产品的核心功能和价值
-2. 分析输出模式的结构，了解页面可用的各个部分(section)
-3. 为每个section规划合适的内容方向，避免内容重复
-4. 针对不同类型的section提供合适的内容规划
-
-请仔细阅读以下输入信息：
-
-## 输入上下文:
+import { getMemory } from '../utils/agent-utils.js';
+import { ReflectionAgent } from '../workflow-agents/reflection-agent.js';
+const pageStructurePlannerPrompt = fs.readFileSync(path.join(__dirname, '../prompts/page-structure-planner-prompt.md'), 'utf-8');
+const pageStructureValidatorPrompt = fs.readFileSync(path.join(__dirname, '../prompts/page-structure-validator-prompt.md'), 'utf-8');
+// 共同的输入参数 schema
+export const plannerParamsSchema = z.object({
+    context: z.string(),
+    question: z.string(),
+    locale: z.string(),
+    outputSchema: z.string(),
+    expectedSections: z.string(),
+});
+const validationFeedbackSchema = z.object({
+    isValid: z.boolean(),
+    missingSections: z.array(z.string()),
+    duplicateContent: z
+        .array(z.object({
+        sections: z.array(z.string()).describe('重复的 sections'),
+        description: z.string().describe('为什么判断为重复'),
+        score: z.number().describe('重复评分，0-100 分'),
+        suggestion: z.string().describe('改进建议，如果需要修改，请给出修改建议'),
+    }))
+        .describe('重复内容的 sections 列表'),
+});
+const contextRule = `
+## 当前任务输入
+上下文信息：
+<context>
 {{context}}
+</context>
 
-## 输出结构模式:
-{{outputSchema}}
-
-## 用户指令:
+用户指令：
+<question>
 {{question}}
+</question>
 
-请注意每个section的描述信息，这将帮助您理解每个section的目的和预期内容。
-
-请按照以下流程工作：
-1. 首先分析上下文，理解产品的核心功能、价值主张和目标用户
-2. 分析输出模式中的sectionsData属性，了解页面包含哪些section
-3. 为每个section规划内容方向，确保各section内容互补而不重复
-4. 返回一个结构化的规划，清楚说明每个section应包含的内容
-5. 如果 Section 中包含列表数据，根据输入上下文中包含的数据，明确指定列表数据的数量，尽可能全的展示上下文中提供的相关数据。
-6. 如果初始结构规划中包含的section，请根据初始结构规划中的内容规划，保持初始结构规划中的内容规划。
-
+输出结构模式：
+<output-schema>
+{{outputSchema}}
+</output-schema>
 
-## 初始结构规划
-{{initialStructurePlan}}
+预期包含的Sections：
+<expected-sections>
+{{expectedSections}}
+</expected-sections>
 
-## 上一轮输出的结构规划
+<#if structurePlan>
+## 当前生成的结构规划：
+<current-structure-plan>
 {{structurePlan}}
+</current-structure-plan>
+</#if>
 
-## 缺失的Section
-{{validationFeedback.missingSections}}
+<#if validationFeedback>
+## 验证反馈
+上一次生成的页面结构规划存在以下问题，请根据反馈建议进行修正：
+<validation-feedback>
+{{validationFeedback}}
+</validation-feedback>
+</#if>
 
-## 内容重复
-{{validationFeedback.duplicateContent}}
+当前时间：${new Date().toISOString()}
+语言：{{locale}}
+`;
+const plannerInstructions = `
+${pageStructurePlannerPrompt}
+
+${contextRule}
+`;
+const validatorInstructions = `
 
-请根据上述反馈修改您的结构规划方案，确保:
-1. 包含所有必要的section
-2. 避免不同section之间内容重复
-3. 明确区分各section的内容方向
-4. 遵循section描述中的要求
+${pageStructureValidatorPrompt}
 
-请为页面的每个section返回一个内容规划，格式为section名称和内容描述, 使用 {{locale}} 语言返回。
+${contextRule}
 `;
-logger.info('page structure planner prompt', prompt);
-export const pageStructurePlannerAgent = AIAgent.from({
-    name: 'Page Structure Planner',
-    subscribeTopic: [UserInputTopic, 'revision_request'],
-    publishTopic: (output) => {
-        logger.info('page structure planner output', JSON.stringify(output.structurePlan));
-        return 'validation_request';
-    },
-    instructions: prompt,
+const memory = getMemory({ autoUpdate: false });
+const structurePlanSchema = z.array(z.object({
+    sectionName: z.string(),
+    sectionContentPlan: z.string().describe('该section的内容规划描述'),
+}));
+const plannerAgent = AIAgent.from({
+    name: 'planner',
+    description: '生成页面结构规划',
+    inputSchema: z.object({
+        ...plannerParamsSchema.shape,
+        validationFeedback: validationFeedbackSchema.optional(),
+        structurePlan: structurePlanSchema.optional(),
+    }),
+    outputSchema: z.object({
+        ...plannerParamsSchema.shape,
+        structurePlan: structurePlanSchema,
+    }),
+    memory,
+    instructions: plannerInstructions,
+    includeInputInOutput: true,
+});
+const validatorAgent = AIAgent.from({
+    name: 'validator',
+    description: '验证页面结构规划的完整性和有效性',
     inputSchema: z.object({
-        context: z.string(),
-        question: z.string(),
-        locale: z.string(),
-        outputSchema: z.string(),
-        expectedSections: z.string(),
-        initialStructurePlan: z.array(z.object({
-            sectionName: z.string(),
-            sectionContentPlan: z.string(),
-        })),
-        validationFeedback: z
-            .object({
-            isValid: z.boolean(),
-            missingSections: z.array(z.string()),
-            duplicateContent: z.array(z.object({
-                sections: z.array(z.string()),
-                description: z.string(),
-                score: z.number(),
-            })),
-        })
-            .optional(),
+        ...plannerParamsSchema.shape,
+        structurePlan: structurePlanSchema,
     }),
+    memory,
     outputSchema: z.object({
-        structurePlan: z.array(z.object({
-            sectionName: z.string(),
-            sectionContentPlan: z.string().describe('该section的内容规划描述'),
-        })),
+        isApproved: z.boolean().describe('结构规划是否符合要求，无缺失 section 且无严重重复内容'),
+        validationFeedback: validationFeedbackSchema,
     }),
+    instructions: validatorInstructions,
     includeInputInOutput: true,
 });
+export const pageStructurePlannerWithReflection = new ReflectionAgent({
+    name: 'page-structure-planner-with-reflection',
+    maxIterations: 2,
+    editor: plannerAgent,
+    reviewer: validatorAgent,
+    isApproved: (result) => result.isApproved,
+});
+// 保留原有的 agent 导出以保持向后兼容
+export const pageStructurePlannerAgent = plannerAgent;

package/lib/esm/agents/router-datacache-generator.d.ts

@@ -0,0 +1,24 @@
+import { FunctionAgent } from '@aigne/core';
+export declare const routerDataCacheGeneratorAgent: FunctionAgent<{
+    context: string;
+    componentList: {
+        data: {
+            name: string;
+            description: string;
+            id: string;
+            component: string;
+            rawData?: any;
+        }[];
+        summary: {
+            total: number;
+            basicComponents: Record<string, string>;
+            customComponents: Record<string, string>;
+        };
+    };
+    templateYaml: string;
+    locale?: string | undefined;
+}, {
+    success: boolean;
+    dataCache?: any;
+    error?: string | undefined;
+}>;

package/lib/esm/agents/router-datacache-generator.js

@@ -0,0 +1,72 @@
+import { FunctionAgent } from '@aigne/core';
+import { generatePageDataZodToAgent } from '@blocklet/pages-kit-block-studio/generate-wrapper-code';
+import yaml from 'js-yaml';
+import { z } from 'zod';
+import { ComponentListOutputSchema } from '../skill-agents/parse-component-list-agent';
+import generatePageContentMultiAgent from './multi-agent-page-writer';
+export const routerDataCacheGeneratorAgent = FunctionAgent.from({
+    name: 'Router Data Cache Generator',
+    description: 'Generate page content using page data and component list, assembling them into state for content generation',
+    inputSchema: z.object({
+        templateYaml: z.string().describe('Template Yaml'),
+        componentList: ComponentListOutputSchema,
+        context: z.string().describe('整理好的上下文信息'),
+        locale: z.string().describe('Locale').default('en').optional(),
+    }),
+    outputSchema: z.object({
+        success: z.boolean(),
+        dataCache: z.any().optional().describe('Generated page data cache'),
+        error: z.string().optional(),
+    }),
+    async process({ templateYaml, componentList, context, locale = 'en' }) {
+        const pageTemplate = yaml.load(templateYaml);
+        const pageTemplateId = pageTemplate.id;
+        try {
+            // Assemble state object from page and componentList
+            const state = {
+                pages: {
+                    [pageTemplateId]: pageTemplate,
+                },
+                // 将 componentList rawData 转换为 components
+                components: Object.fromEntries(componentList.data
+                    .filter((component) => component.rawData)
+                    .map((component, index) => [
+                    component.id,
+                    {
+                        index,
+                        data: component.rawData,
+                    },
+                ])),
+                resources: {
+                    components: {},
+                },
+            };
+            // Generate output schema using the assembled state
+            const outputSchema = generatePageDataZodToAgent(state, pageTemplateId);
+            if (!outputSchema) {
+                return {
+                    success: false,
+                    error: 'Failed to generate output schema',
+                };
+            }
+            // Generate page content using the multi-agent
+            const dataCache = await generatePageContentMultiAgent({
+                context,
+                question: 'Please generate the page content based on the context',
+                locale,
+                outputSchema,
+            });
+            return {
+                success: true,
+                dataCache,
+            };
+        }
+        catch (error) {
+            console.error('Error in router dataCache generation:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error during generation',
+            };
+        }
+    },
+});

package/lib/esm/agents/section-content-generator.js

@@ -1,7 +1,9 @@
 import { AIAgent } from '@aigne/core';
 import { zodSchemaToJsonSchema } from '@blocklet/pages-kit-block-studio/zod-utils';
 import { z } from 'zod';
+// import { getMemory } from '../utils/agent-utils.js';
 import { logger } from '../utils/logger.js';
+// const memory = getMemory({ autoUpdate: false });
 export async function createSectionContentAgent(input) {
     const prompt = `您是一名有着丰富经验且富有创意的设计师，擅长产品站点的内容创作。
 
@@ -19,7 +21,7 @@ export async function createSectionContentAgent(input) {
 
 Hero Section 中的标题必须能充分描述上下文中的产品，标题应该是描述，而不是口号，让用户打开网页第一眼就知道了产品是什么，能帮助用户做什么。
 
-HeroSection 中的描述可以包含两点信息：
+Hero Section 中的描述可以包含两点信息：
 - 我们的产品如何工作的
 - 支撑标题中的描述，让它更可信
 
@@ -41,11 +43,11 @@ FAQ 中的问答应该包含用户常关心的问题，并给出答案，如果
 ## 用户指令:
 {{question}}
 
-## 当前section信息
-Section名称: {{sectionName}}
-Section计划: {{sectionPlan}}
+## 当前 section 信息
+Section 名称: {{sectionName}}
+Section 计划: {{sectionPlan}}
 
-注意：Section计划是对这个 section 需要展示的内容和风格的要求，您需要根据这个要求来生成面向用户，对用户阅读友好的内容，不要直接重复 section 计划中的要求。
+注意：Section 计划是对这个 section 需要展示的内容和风格的要求，您需要根据这个要求来生成面向用户，对用户阅读友好的内容，不要直接重复 section 计划中的要求。
 
 ## 数据格式要求
 ${JSON.stringify(zodSchemaToJsonSchema(input.sectionSchema))}
@@ -55,9 +57,9 @@ ${JSON.stringify(zodSchemaToJsonSchema(input.sectionSchema))}
 
 
 ## 内容生成要求
-1. 仅生成当前指定section的内容
-2. 避免与已生成的section内容重复
-3. 内容要围绕section计划描述的主题展开
+1. 仅生成当前指定 section 的内容
+2. 避免与已生成的 section 内容重复
+3. 内容要围绕 section 计划描述的主题展开
 4. 上下文中有相关图片时返回图片链接，如果没有相关的图片不要随便使用其他图片
 5. 如果数组类型确实没有数据，请返回空数组
 6. 内容需符合提供的数据格式要求
@@ -89,6 +91,7 @@ ${JSON.stringify(zodSchemaToJsonSchema(input.sectionSchema))}
             generatedSections: z.string(),
         }),
         outputSchema: input.sectionSchema,
+        // memory,
     });
     return agent;
 }

package/lib/esm/agents/template-designer.d.ts

@@ -1,13 +1,14 @@
 import { AIAgent } from '@aigne/core';
-/**
- * 用于设计页面结构的 workflow
- * 1. AI 根据拿到的 collectorResult 和 componentList，生成一个页面设计模板，需要用 ASCII 图画出来，给到用户确认
- * 2. 用户确认后，AI 保存页面设计模板，并返回页面设计模板
- */
 export declare const designerAgent: AIAgent<{
+    componentListYaml: string;
     collectResult: string;
 }, {
     ascii: string;
     $message: string;
-    filteredComponentList: string[];
+    filteredComponentList: {
+        name: string;
+        description: string;
+        id: string;
+        component: string;
+    }[];
 }>;