Prompt 链与多步工作流编排

顺序 Sequential   A → B → C → D
并行 Fan-out      A → [B,C,D 并行] → merge
路由 Router       A → (条件) → B | C | D
循环 Loop         A → B → (满意?) ─ 否 ─→ B ...
                         └ 是 ─→ 输出

type Step<I, O> = (input: I) => Promise<O>;

// 顺序
const chain = async (topic: string) => {
  const research = await researchStep(topic);
  const outline  = await outlineStep(research);
  const draft    = await draftStep(outline);
  return polishStep(draft);
};

// 并行 fan-out + merge
const summarizeMany = async (chunks: string[]) => {
  const parts = await Promise.all(chunks.map(summarizeStep));
  return mergeStep(parts);
};

// 路由
const route = async (q: string) => {
  const kind = await classifyStep(q);          // 'tech' | 'chat' | 'block'
  return kind === 'tech'  ? expertStep(q)
       : kind === 'chat'  ? lightStep(q)
                          : refuseStep();
};

// 循环(带硬上限)
const refine = async (topic: string) => {
  let draft = await draftStep(topic);
  for (let i = 0; i < 3; i++) {
    const critique = await critiqueStep(draft);
    if (critique.score >= 8) break;
    draft = await reviseStep(draft, critique);
  }
  return draft;
};

// ❌ 反例:自然语言串接,噪声大、不可解析
const outline = await llm(`基于这些研究写大纲:${researchText}`);
const draft   = await llm(`基于这个大纲写正文:${outline}`);

// ✅ 正例:结构化 schema 传递,B 只取需要的字段
type Research = { keyFacts: string[]; sources: {title:string;url:string}[]; gaps: string[] };
type Outline  = { sections: { heading: string; points: string[] }[] };

const research: Research = await researchStep(topic);     // 强制 JSON schema
const outline:  Outline  = await outlineStep(research);   // 只读 research.keyFacts
const draft              = await draftStep(outline);

const withRetry = async <T>(fn: () => Promise<T>, times = 3): Promise<T> => {
  let lastErr: unknown;
  for (let i = 0; i < times; i++) {
    try { return await fn(); }
    catch (e) { lastErr = e; await sleep(2 ** i * 500); }
  }
  throw lastErr;
};

// 幂等:中间结果落库,按 (taskId, stepName, inputHash) 去重
const runStep = async (taskId: string, step: string, input: unknown) => {
  const key = `${taskId}:${step}:${hash(input)}`;
  const cached = await db.get(key);
  if (cached) return cached;              // 重放时跳过已完成步
  const out = await withRetry(() => steps[step](input));
  await db.set(key, out);
  return out;
};

type Ctx = { topic: string; research?: Research; outline?: Outline;
             draft?: string; article?: string };

const generateArticle = async (topic: string): Promise<string> => {
  let ctx: Ctx = { topic };

  // 1. 研究:Agent 子步,自主检索(开放探索 → 用 Agent)
  ctx.research = await runStep(topic, 'research', topic);

  // 2. 大纲:确定性步,裁剪上下文,只传 keyFacts
  ctx.outline  = await runStep(topic, 'outline', ctx.research.keyFacts);

  // 3. 起草:循环链,自评+修订,最多 2 轮
  ctx.draft    = await runStep(topic, 'draft',
    { outline: ctx.outline, facts: ctx.research.keyFacts, maxRounds: 2 });

  // 4. 润色:小模型也能做,换便宜模型 + prompt caching
  ctx.article  = await runStep(topic, 'polish', ctx.draft);
  return ctx.article;
};