@blocklet/pages-kit-agents 0.5.45 → 0.5.48

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

@@ -1,3 +1,7 @@
+import { FSMemory, FSMemoryOptions } from '@aigne/agent-library/fs-memory/index.js';
 import { AnthropicChatModel } from '@aigne/anthropic';
 import { OpenAIChatModel } from '@aigne/openai';
 export declare function getModel(modelName?: string): OpenAIChatModel | AnthropicChatModel | undefined;
+export declare function getMemory({ projectId, ...rest }: Pick<FSMemoryOptions, 'autoUpdate'> & {
+    projectId?: string;
+}): FSMemory;

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

@@ -4,13 +4,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModel = getModel;
+exports.getMemory = getMemory;
+const index_js_1 = require("@aigne/agent-library/fs-memory/index.js");
 const anthropic_1 = require("@aigne/anthropic");
 const deepseek_1 = require("@aigne/deepseek");
 const gemini_1 = require("@aigne/gemini");
 const openai_1 = require("@aigne/openai");
 const xai_1 = require("@aigne/xai");
 const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
 const { OPENAI_API_KEY, GEMINI_API_KEY, CLAUDE_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY } = process.env;
+// === 内置 prompt 内容，避免运行时读取文件 ===
+const recorderInstructions = `你是一个智能的站点生成记忆管理器，负责从多轮对话和用户反馈中提取对后续站点生成有用的知识和偏好，并以结构化方式存储。
+
+## 你的任务
+
+- 只记录对后续站点生成、内容补全、页面设计、组件选择、风格偏好等有实际帮助的信息。
+- 忽略无效、重复、无关、泛泛的内容。
+- 将新的对话中，有用的信息补充到记忆中，重点记忆用户的反馈
+- **不允许删除 existing-memory 中的记忆**
+
+## 需要记录的内容示例
+
+- 用户对产品/服务/公司/行业的补充、修正、详细描述
+- 用户对目标用户、USP、CTA、痛点、案例等内容补全问题的详细回答
+- 用户对 SiteMap、页面结构、模板设计的反馈、偏好、否定/肯定意见
+- 用户对文案风格、页面布局、组件选择、品牌色彩等的明确要求
+- 用户对行业、竞品、特殊需求的补充说明
+- 用户对生成结果的纠错、修正、特殊说明
+- 任何跨页面/全局性的偏好、约束、风格、品牌要求
+
+## 不要记录的内容
+
+- 一般性寒暄、确认、无实际内容的反馈
+- 纯粹的系统提示、流程性对话
+- 与站点生成无关的闲聊、无效输入
+- 已经被记忆、无新意的重复内容
+- 页面中使用了什么组件
+
+## 操作流程
+
+1. 读取所有历史记忆（existing-memory）
+2. 分析当前对话内容（conversation），提取有用信息
+3. 判断是否需要新增、更新
+4. 会有多个 Agent 共用当前记忆，现有记忆可能和当前对话无关，保留这些记忆不做修改
+5. 如果当前对话中信息对现有记忆有更新，可以更新现有记忆
+6. **不允许删除 existing-memory 的记忆，可以更新**
+7. 返回所有有用记忆
+
+## 记忆结构
+
+- 每条记忆应简明扼要，内容聚焦于"对后续站点生成有帮助"的知识、偏好、约束
+- 不要存储无关、冗余、重复内容
+
+## 记忆输出格式
+
+- 返回所有有用记忆（existing + new），每条为独立对象
+- existing-memory 中的记忆必须返回，条数不能减少，其中的记忆可以有更新
+- 使用 zh 语言记录
+
+## 现有记忆
+
+<existing-memory>
+{{allMemory}}
+</existing-memory>
+
+## 当前对话
+
+<conversation>
+{{content}}
+</conversation>
+`;
+const retrieverInstructions = `你是一个智能的站点生成记忆检索器，负责从所有历史记忆中筛选出与当前任务最相关、最有帮助的内容，供后续 Agent 使用。
+
+## 检索原则
+
+- 只返回与当前任务、页面、实体、主题、设计决策等密切相关的记忆
+- 优先返回能直接影响当前内容补全、页面设计、组件选择、风格设定等的记忆
+- 忽略与当前任务无关的记忆
+- 如果记忆描述出现冲突，返回后出现的记忆内容
+
+## 检索流程
+
+1. 读取所有历史记忆（allMemory）
+2. 分析当前检索请求（search/query），提取关键主题
+3. 匹配并返回最相关的记忆内容（可多条）
+
+## 记忆输出格式
+
+- 返回所有与当前任务最相关的记忆，每条为独立对象
+
+## 现有记忆
+
+<existing-memory>
+{{allMemory}}
+</existing-memory>
+
+## 检索请求
+
+<search-query>
+{{search}}
+</search-query>
+`;
 function getModel(modelName = 'openai') {
     if (modelName?.includes('gpt')) {
         (0, node_assert_1.default)(OPENAI_API_KEY, 'Please set the OPENAI_API_KEY environment variable');
@@ -60,3 +155,14 @@ function getModel(modelName = 'openai') {
     }
     return undefined;
 }
+function getMemory({ projectId = 'debug', ...rest }) {
+    // === FSMemory 配置 ===
+    const memoryRootDir = node_path_1.default.join(process.cwd(), 'project-records', projectId, 'memory');
+    const fsMemory = new index_js_1.FSMemory({
+        ...(rest || {}),
+        rootDir: memoryRootDir,
+        recorderOptions: { instructions: recorderInstructions },
+        retrieverOptions: { instructions: retrieverInstructions },
+    });
+    return fsMemory;
+}

package/lib/esm/agents/content-reviwer.d.ts

@@ -10,8 +10,8 @@ export declare const contentReviewerAgent: AIAgent<{
         level: string;
         suggestions: string[];
         dimension_scores: {
-            score: number;
             name: string;
+            score: number;
             maxScore: number;
             comment: string;
         }[];

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

@@ -1,10 +1,9 @@
-import { AIGNE, UserOutputTopic } from '@aigne/core';
+import { AIGNE } 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 { pageStructurePlannerWithReflection } from './page-structure-planner.js';
 import { createSectionContentAgent } from './section-content-generator.js';
 /**
  * 多Agent协作生成页面内容
@@ -52,26 +51,20 @@ export default async function generatePageContentMultiAgent(input) {
         // 3-4 使用反思工作流生成页面结构
         const planningEngine = new AIGNE({
             model,
-            agents: [pageStructurePlannerAgent, pageStructureValidatorAgent],
-            limits: {
-                maxAgentInvokes: 30,
-            },
         });
-        await planningEngine.invoke(pageStructurePlannerAgent, {
+        const structurePlanResult = await planningEngine.invoke(pageStructurePlannerWithReflection, {
             context,
             question,
             locale,
-            initialStructurePlan: Object.entries(sectionsRules || {}).map(([sectionName, sectionContentPlan]) => ({
+            structurePlan: 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(`[${modelName}] Initial structure plan generated`, structurePlan);
-        await planningEngine.shutdown();
         // 触发页面结构生成成功事件
         if (onProgress) {
             onProgress({

package/lib/esm/agents/orchestrator/index.d.ts

@@ -0,0 +1,115 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from '@aigne/core';
+import { type FullPlanOutput, type StepWithResult } from './orchestrator-prompts.js';
+/**
+ * Re-export orchestrator prompt templates and related types
+ */
+export * from './orchestrator-prompts.js';
+/**
+ * Represents a complete plan with execution results
+ * @hidden
+ */
+export interface FullPlanWithResult {
+    /**
+     * The overall objective
+     */
+    objective: string;
+    /**
+     * The generated complete plan
+     */
+    plan?: FullPlanOutput;
+    /**
+     * List of executed steps with their results
+     */
+    steps: StepWithResult[];
+    /**
+     * Final result
+     */
+    result?: string;
+    /**
+     * Plan completion status
+     */
+    status?: boolean;
+}
+/**
+ * Configuration options for the Orchestrator Agent
+ */
+export interface OrchestratorAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
+    /**
+     * Maximum number of iterations to prevent infinite loops
+     * Default: 30
+     */
+    maxIterations?: number;
+    /**
+     * Number of concurrent tasks
+     * Default: 5
+     */
+    tasksConcurrency?: number;
+    /**
+     * Chain step results as input to the next step
+     * Default: false
+     */
+    chainStepResults?: boolean;
+}
+/**
+ * Orchestrator Agent Class
+ *
+ * This Agent is responsible for:
+ * 1. Generating an execution plan based on the objective
+ * 2. Breaking down the plan into steps and tasks
+ * 3. Coordinating the execution of steps and tasks
+ * 4. Synthesizing the final result
+ *
+ * Workflow:
+ * - Receives input objective
+ * - Uses planner to create execution plan
+ * - Executes tasks and steps according to the plan
+ * - Synthesizes final result through completer
+ */
+export declare class OrchestratorAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    /**
+     * Factory method to create an OrchestratorAgent instance
+     * @param options - Configuration options for the Orchestrator Agent
+     * @returns A new OrchestratorAgent instance
+     */
+    static from<I extends Message, O extends Message>(options: OrchestratorAgentOptions<I, O>): OrchestratorAgent<I, O>;
+    /**
+     * Creates an OrchestratorAgent instance
+     * @param options - Configuration options for the Orchestrator Agent
+     */
+    constructor(options: OrchestratorAgentOptions<I, O>);
+    private planner;
+    private completer;
+    /**
+     * Maximum number of iterations
+     * Prevents infinite execution loops
+     */
+    maxIterations?: number;
+    /**
+     * Number of concurrent tasks
+     * Controls how many tasks can be executed simultaneously
+     */
+    tasksConcurrency?: number;
+    /**
+     * Whether to chain step results as input to next step
+     */
+    chainStepResults?: boolean;
+    /**
+     * Process input and execute the orchestrator workflow
+     *
+     * Workflow:
+     * 1. Extract the objective
+     * 2. Loop until plan completion or maximum iterations:
+     *    a. Generate/update execution plan
+     *    b. If plan is complete, synthesize result
+     *    c. Otherwise, execute steps in the plan
+     *
+     * @param input - Input message containing the objective
+     * @param options - Agent invocation options
+     * @returns Processing result
+     */
+    process(input: I, options: AgentInvokeOptions): Promise<O>;
+    private getFullPlanInput;
+    private getFullPlan;
+    private synthesizePlanResult;
+    private executeStep;
+}

package/lib/esm/agents/orchestrator/index.js

@@ -0,0 +1,243 @@
+/* eslint-disable no-await-in-loop */
+import { AIAgent, Agent, MESSAGE_KEY, PromptTemplate, createMessage, getMessage, } from '@aigne/core';
+import { checkArguments } from '@aigne/core/utils/type-utils.js';
+import fastq from 'fastq';
+import { z } from 'zod';
+import { FULL_PLAN_PROMPT_TEMPLATE, SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE, SYNTHESIZE_STEP_PROMPT_TEMPLATE, TASK_PROMPT_TEMPLATE, getFullPlanSchema, } from './orchestrator-prompts.js';
+/**
+ * Default maximum number of iterations to prevent infinite loops
+ */
+const DEFAULT_MAX_ITERATIONS = 30;
+/**
+ * Default number of concurrent tasks
+ */
+const DEFAULT_TASK_CONCURRENCY = 5;
+/**
+ * Re-export orchestrator prompt templates and related types
+ */
+export * from './orchestrator-prompts.js';
+/**
+ * Orchestrator Agent Class
+ *
+ * This Agent is responsible for:
+ * 1. Generating an execution plan based on the objective
+ * 2. Breaking down the plan into steps and tasks
+ * 3. Coordinating the execution of steps and tasks
+ * 4. Synthesizing the final result
+ *
+ * Workflow:
+ * - Receives input objective
+ * - Uses planner to create execution plan
+ * - Executes tasks and steps according to the plan
+ * - Synthesizes final result through completer
+ */
+export class OrchestratorAgent extends Agent {
+    /**
+     * Factory method to create an OrchestratorAgent instance
+     * @param options - Configuration options for the Orchestrator Agent
+     * @returns A new OrchestratorAgent instance
+     */
+    static from(options) {
+        return new OrchestratorAgent(options);
+    }
+    /**
+     * Creates an OrchestratorAgent instance
+     * @param options - Configuration options for the Orchestrator Agent
+     */
+    constructor(options) {
+        checkArguments('OrchestratorAgent', orchestratorAgentOptionsSchema, options);
+        super({ ...options });
+        this.maxIterations = options.maxIterations;
+        this.tasksConcurrency = options.tasksConcurrency;
+        this.chainStepResults = options.chainStepResults;
+        this.planner = new AIAgent({
+            name: 'llm_orchestration_planner',
+            instructions: FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: () => getFullPlanSchema(this.skills),
+        });
+        this.completer = new AIAgent({
+            name: 'llm_orchestration_completer',
+            instructions: FULL_PLAN_PROMPT_TEMPLATE,
+            outputSchema: this.outputSchema,
+        });
+    }
+    planner;
+    completer;
+    /**
+     * Maximum number of iterations
+     * Prevents infinite execution loops
+     */
+    maxIterations;
+    /**
+     * Number of concurrent tasks
+     * Controls how many tasks can be executed simultaneously
+     */
+    tasksConcurrency;
+    /**
+     * Whether to chain step results as input to next step
+     */
+    chainStepResults;
+    /**
+     * Process input and execute the orchestrator workflow
+     *
+     * Workflow:
+     * 1. Extract the objective
+     * 2. Loop until plan completion or maximum iterations:
+     *    a. Generate/update execution plan
+     *    b. If plan is complete, synthesize result
+     *    c. Otherwise, execute steps in the plan
+     *
+     * @param input - Input message containing the objective
+     * @param options - Agent invocation options
+     * @returns Processing result
+     */
+    async process(input, options) {
+        const { model } = options.context;
+        if (!model)
+            throw new Error('model is required to run OrchestratorAgent');
+        const objective = getMessage(input);
+        if (!objective)
+            throw new Error('Objective is required to run OrchestratorAgent');
+        const result = {
+            objective,
+            steps: [],
+        };
+        let iterations = 0;
+        const maxIterations = this.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        while (iterations++ < maxIterations) {
+            const plan = await this.getFullPlan(result, options.context);
+            result.plan = plan;
+            if (plan.isComplete) {
+                return this.synthesizePlanResult(result, options.context);
+            }
+            for (const step of plan.steps) {
+                const stepResult = await this.executeStep(result, step, options.context);
+                result.steps.push(stepResult);
+            }
+        }
+        throw new Error(`Max iterations reached: ${maxIterations}`);
+    }
+    getFullPlanInput(planResult) {
+        return {
+            objective: planResult.objective,
+            steps: planResult.steps,
+            plan: {
+                status: planResult.status ? 'Complete' : 'In Progress',
+                result: planResult.result || 'No results yet',
+            },
+            agents: this.skills.map((i) => ({
+                name: i.name,
+                description: i.description,
+                tools: i.skills.map((i) => ({ name: i.name, description: i.description })),
+            })),
+        };
+    }
+    async getFullPlan(planResult, context) {
+        return context.invoke(this.planner, this.getFullPlanInput(planResult));
+    }
+    async synthesizePlanResult(planResult, context) {
+        return context.invoke(this.completer, {
+            ...this.getFullPlanInput(planResult),
+            ...createMessage(SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE),
+        });
+    }
+    async executeStep(planResult, step, context) {
+        const concurrency = this.tasksConcurrency ?? DEFAULT_TASK_CONCURRENCY;
+        const { model } = context;
+        if (!model)
+            throw new Error('model is required to run OrchestratorAgent');
+        let lastTaskResult = {};
+        // 将上一步最后一个任务的输入作为下一步的输入
+        if (this.chainStepResults) {
+            if (planResult.steps.length > 0) {
+                const lastStep = planResult.steps[planResult.steps.length - 1];
+                if (lastStep?.result) {
+                    try {
+                        const lastStepResult = JSON.parse(lastStep.result);
+                        if (lastStepResult?.step?.results && Array.isArray(lastStepResult.step.results) && lastStepResult.step.results.length > 0) {
+                            const lastStepResults = lastStepResult.step.results[lastStepResult.step.results.length - 1];
+                            console.log('lastStepResults', lastStepResults.result);
+                            lastTaskResult = JSON.parse(lastStepResults.result);
+                        }
+                    }
+                    catch (error) {
+                        console.error('Failed to parse last step result', error);
+                    }
+                }
+            }
+        }
+        const queue = fastq.promise(async (task) => {
+            const agent = this.skills.find((skill) => skill.name === task.agent);
+            if (!agent)
+                throw new Error(`Agent ${task.agent} not found`);
+            const prompt = PromptTemplate.from(TASK_PROMPT_TEMPLATE).format({
+                // eslint-disable-next-line prettier/prettier
+                objective: planResult.objective,
+                step,
+                task,
+                steps: planResult.steps,
+            });
+            let result;
+            if (agent.isInvokable) {
+                result = getMessageOrJsonString(await context.invoke(agent, { ...lastTaskResult, [MESSAGE_KEY]: prompt }));
+            }
+            else {
+                const executor = AIAgent.from({
+                    name: 'llm_orchestration_task_executor',
+                    instructions: prompt,
+                    skills: agent.skills,
+                });
+                result = getMessageOrJsonString(await context.invoke(executor, this.chainStepResults ? { ...lastTaskResult } : {}));
+            }
+            return { task, result };
+        }, concurrency);
+        let results;
+        try {
+            results = await Promise.all(step.tasks.map((task) => queue.push(task)));
+        }
+        catch (error) {
+            queue.kill();
+            throw error;
+        }
+        let result = '';
+        if (!this.chainStepResults) {
+            result = getMessageOrJsonString(await context.invoke(AIAgent.from({
+                name: 'llm_orchestration_step_synthesizer',
+                instructions: SYNTHESIZE_STEP_PROMPT_TEMPLATE,
+            }), { objective: planResult.objective, step, tasks: results }));
+        }
+        else {
+            const resultData = {
+                step: {
+                    description: step.description,
+                    results: results.map((task) => ({
+                        agent: task.task.agent,
+                        task: task.task.description,
+                        result: task.result,
+                    })),
+                },
+            };
+            result = JSON.stringify(resultData);
+        }
+        if (!result)
+            throw new Error('unexpected empty result from synthesize step\'s tasks results');
+        return {
+            step,
+            tasks: results,
+            result,
+        };
+    }
+}
+function getMessageOrJsonString(output) {
+    const entries = Object.entries(output);
+    const firstValue = entries[0]?.[1];
+    if (entries.length === 1 && typeof firstValue === 'string') {
+        return firstValue;
+    }
+    return JSON.stringify(output);
+}
+const orchestratorAgentOptionsSchema = z.object({
+    maxIterations: z.number().optional(),
+    tasksConcurrency: z.number().optional(),
+    chainStepResults: z.boolean().optional(),
+});

package/lib/esm/agents/orchestrator/orchestrator-prompts.d.ts

@@ -0,0 +1,130 @@
+import type { Agent, Message } from '@aigne/core';
+import { z } from 'zod';
+/**
+ * @hidden
+ */
+export declare const SYNTHESIZE_PLAN_USER_PROMPT_TEMPLATE = "Synthesize the results of executing all steps in the plan into a cohesive result\n";
+/**
+ * @hidden
+ */
+export declare function getFullPlanSchema(agents: Agent[]): z.ZodObject<{
+    steps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            agent: z.ZodUnion<[z.ZodLiteral<string>, z.ZodLiteral<string>, ...z.ZodLiteral<string>[]]>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            agent: string;
+        }, {
+            description: string;
+            agent: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }, {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }>, "many">;
+    isComplete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    isComplete: boolean;
+}, {
+    steps: {
+        description: string;
+        tasks: {
+            description: string;
+            agent: string;
+        }[];
+    }[];
+    isComplete: boolean;
+}>;
+/**
+ * @hidden
+ */
+export type FullPlanOutput = z.infer<ReturnType<typeof getFullPlanSchema>>;
+/**
+ * @hidden
+ */
+export type Step = FullPlanOutput['steps'][number];
+/**
+ * @hidden
+ */
+export type Task = Step['tasks'][number];
+/**
+ * @hidden
+ */
+export interface StepWithResult {
+    step: Step;
+    tasks: Array<TaskWithResult>;
+    result: string;
+}
+/**
+ * @hidden
+ */
+export interface TaskWithResult {
+    task: Task;
+    result: string;
+}
+/**
+ * @hidden
+ */
+export interface FullPlanInput extends Message {
+    objective: string;
+    steps: StepWithResult[];
+    plan: {
+        status: string;
+        result: string;
+    };
+    agents: {
+        name: string;
+        description?: string;
+        tools: {
+            name: string;
+            description?: string;
+        }[];
+    }[];
+}
+/**
+ * @hidden
+ */
+export declare const FULL_PLAN_PROMPT_TEMPLATE = "You are tasked with orchestrating a plan to complete an objective.\nYou can analyze results from the previous steps already executed to decide if the objective is complete.\nYour plan must be structured in sequential steps, with each step containing independent parallel subtasks.\n\n<objective>\n{{objective}}\n</objective>\n\n<steps_completed>\n{{#steps}}\n- Step: {{step.description}}\n  Result: {{result}}\n{{/steps}}\n</steps_completed>\n\n<previous_plan_status>\n{{plan.status}}\n</previous_plan_status>\n\n<previous_plan_result>\n{{plan.result}}\n</previous_plan_result>\n\nYou have access to the following Agents(which are collections of tools/functions):\n\n<agents>\n{{#agents}}\n- Agent: {{name}}\n  Description: {{description}}\n  Functions:\n    {{#tools}}\n    - Tool: {{name}}\n      Description: {{description}}\n    {{/tools}}\n{{/agents}}\n</agents>\n\n- If the previous plan results achieve the objective, return isComplete=true.\n- Otherwise, generate remaining steps needed.\n- Generate a plan with all remaining steps needed.\n- Steps are sequential, but each Step can have parallel subtasks.\n- For each Step, specify a description of the step and independent subtasks that can run in parallel.\n- For each subtask specify:\n    1. Clear description of the task that an LLM can execute\n    2. Name of 1 Agent to use for the task";
+/**
+ * @hidden
+ */
+export interface TaskPromptInput extends Message {
+    objective: string;
+    step: Step;
+    task: Task;
+    steps: StepWithResult[];
+}
+/**
+ * @hidden
+ */
+export declare const TASK_PROMPT_TEMPLATE = "You are part of a larger workflow to achieve the step then the objective:\n\n<objective>\n{{objective}}\n</objective>\n\n<step>\n{{step.description}}\n</step>\n\nYour job is to accomplish only the following task:\n\n<task>\n{{task.description}}\n</task>\n\nResults so far that may provide helpful context:\n\n<steps_completed>\n{{#steps}}\n- Step: {{step.description}}\n  Result: {{result}}\n{{/steps}}\n</steps_completed>\n";
+/**
+ * @hidden
+ */
+export interface SynthesizeStepPromptInput extends Message {
+    objective: string;
+    step: Step;
+    tasks: TaskWithResult[];
+}
+/**
+ * @hidden
+ */
+export declare const SYNTHESIZE_STEP_PROMPT_TEMPLATE = "Synthesize the results of these parallel tasks into a cohesive result\n\n<objective>\n{{objective}}\n</objective>\n\n<step>\n{{step.description}}\n</step>\n\n<tasks>\n{{#tasks}}\n- Task: {{task.description}}\n  Result: {{result}}\n{{/tasks}}\n</tasks>\n";