import { RunnableSequence } from "@langchain/core/runnables";
 
// 写法 1：显式构造
const chain = RunnableSequence.from([step1, step2, step3]);
 
// 写法 2：链式 pipe
const chain = step1.pipe(step2).pipe(step3);

// chain-sequence.ts
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
 
// prompt: 把变量插进模板
const prompt = ChatPromptTemplate.fromTemplate(
  "用一句话解释什么是 {concept}",
);
 
// 模型：用 GPT-4o 做演示，正式项目按场景选 Claude Sonnet 4.6 / GPT-5
const model = new ChatOpenAI({ model: "gpt-4o" });
 
// parser: 把 AIMessage 转成纯字符串
const parser = new StringOutputParser();
 
const chain = prompt.pipe(model).pipe(parser);
 
const result = await chain.invoke({ concept: "量子纠缠" });
console.log(result);
// => "量子纠缠是指两个粒子无论相距多远都能瞬间相互影响的量子力学现象。"

OPENAI_API_KEY=sk-xxx npx tsx chain-sequence.ts

// [bad] 编译期报错：缺少 concept 字段
await chain.invoke({ topic: "黑洞" });

const chain = prompt
  .pipe(model)
  .pipe(parser)
  // 自动包装成 RunnableLambda
  .pipe((text: string) => text.toUpperCase());

// [bad] 类型断裂
.pipe((input) => input.length)
 
// [ok] 显式标注
.pipe((input: string) => input.length)

import { RunnablePassthrough } from "@langchain/core/runnables";
 
const chain = RunnablePassthrough.assign({
  // 在原始输入对象上挂一个新字段 answer
  answer: prompt.pipe(model).pipe(parser),
}).pipe(
  (input: { concept: string; answer: string }) =>
    `问题：${input.concept}\n回答：${input.answer}`,
);
 
const result = await chain.invoke({ concept: "量子纠缠" });
// => "问题：量子纠缠\n回答：量子纠缠是指..."

await chain.invoke(
  { concept: "递归" },
  {
    // 运行时上下文：tenantId、userId、abTestGroup 这类业务字段都放这里
    context: { userId: "u_42", tenantId: "acme" },
    // 给本次调用打 tag，便于在 LangSmith 里过滤
    tags: ["demo"],
    runName: "concept-explainer",
  },
);

import { RunnableLambda } from "@langchain/core/runnables";
 
const logger = new RunnableLambda({
  func: (input: string, config) => {
    const userId = config?.context?.userId ?? "anonymous";
    console.log(`[${userId}] 接收到输入：${input}`);
    return input;
  },
});

const risky = RunnableSequence.from([
  (input: string) => {
    console.log("step 1");
    return input;
  },
  (_: string) => {
    throw new Error("API 限流");
  },
  (input: string) => {
    console.log("step 3"); // 永远不会执行
    return input;
  },
]);
 
try {
  await risky.invoke("hello");
} catch (e) {
  console.error((e as Error).message); // "API 限流"
}

// review-pipeline.ts
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { RunnableSequence } from "@langchain/core/runnables";
import { z } from "zod";
 
// 1. 定义结构化输出 schema
const reviewSchema = z.object({
  summary: z.string().describe("一句话总结"),
  pros: z.array(z.string()).describe("优点列表"),
  cons: z.array(z.string()).describe("缺点列表"),
  rating: z.number().min(1).max(5).describe("1-5 评分"),
});
 
// 2. 用 withStructuredOutput 替代手写 parser
//    1.x 推荐显式传 strategy: "tool"（基于 function calling，最稳）
const model = new ChatOpenAI({ model: "gpt-4o", temperature: 0 });
const structuredModel = model.withStructuredOutput(reviewSchema, {
  strategy: "tool",
});
 
// 3. prompt
const prompt = ChatPromptTemplate.fromTemplate(`
你是一位严谨的产品评测师。请根据用户反馈对产品做结构化评测。
 
产品名称：{product}
用户反馈：{feedback}
`);
 
// 4. 后处理：把 rating 渲染成星星
function addRatingDisplay(review: z.infer<typeof reviewSchema>) {
  const stars = "★".repeat(review.rating) + "☆".repeat(5 - review.rating);
  return { ...review, display: `${stars} (${review.rating}/5)` };
}
 
// 5. 组合
const reviewChain = RunnableSequence.from([
  prompt,
  structuredModel,
  addRatingDisplay,
]);
 
// 6. 执行
const result = await reviewChain.invoke({
  product: "AirPods Pro 2",
  feedback: "降噪很好，续航一般，戴久了耳朵痛",
});
 
console.log(result);
// {
//   summary: "降噪出色但续航和舒适度有待提升的真无线耳机",
//   pros: ["降噪效果优秀", "音质清晰"],
//   cons: ["续航一般", "长时间佩戴不适"],
//   rating: 3,
//   display: "★★★☆☆ (3/5)",
// }

// translation-pipeline.ts
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { RunnableSequence } from "@langchain/core/runnables";
import { z } from "zod";
 
const model = new ChatOpenAI({ model: "gpt-4o", temperature: 0.3 });
const parser = new StringOutputParser();
 
// 子链 1：检测语言
const detectLang = ChatPromptTemplate.fromTemplate(
  "检测以下文本是什么语言，只返回语言名称（English / 中文 / 日本語 ...）：\n{text}",
)
  .pipe(model)
  .pipe(parser);
 
// 子链 2：翻译
const translate = ChatPromptTemplate.fromTemplate(
  "把以下 {sourceLang} 文本翻译成 {targetLang}，保持原文风格：\n{text}",
)
  .pipe(model)
  .pipe(parser);
 
// 子链 3：质量评估（结构化输出）
const qualitySchema = z.object({
  score: z.number().min(1).max(10),
  suggestions: z.array(z.string()),
});
const qualityCheck = ChatPromptTemplate.fromTemplate(
  `对比原文和译文，给出 1-10 分和改进建议。
原文（{sourceLang}）：{text}
译文（{targetLang}）：{translation}`,
)
  .pipe(model.withStructuredOutput(qualitySchema, { strategy: "tool" }));
 
// 主链：把三个子链按顺序串起来，每步都把中间结果合并回输入
const pipeline = RunnableSequence.from([
  async (input: { text: string; targetLang: string }) => ({
    ...input,
    sourceLang: (await detectLang.invoke({ text: input.text })).trim(),
  }),
  async (input) => ({
    ...input,
    translation: await translate.invoke(input),
  }),
  async (input) => ({
    originalText: input.text,
    sourceLang: input.sourceLang,
    targetLang: input.targetLang,
    translation: input.translation,
    quality: await qualityCheck.invoke(input),
  }),
]);
 
const result = await pipeline.invoke({
  text: "The quick brown fox jumps over the lazy dog.",
  targetLang: "中文",
});
 
console.log(result);
// {
//   originalText: "The quick brown fox jumps over the lazy dog.",
//   sourceLang: "English",
//   targetLang: "中文",
//   translation: "敏捷的棕色狐狸跳过了那只懒狗。",
//   quality: { score: 8, suggestions: ["可以考虑更文学化的表达"] },
// }