import { createAgent, summarizationMiddleware } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const agent = createAgent({
  model,
  tools: [],
  checkpointer: new MemorySaver(),   // 摘要要跨多轮累积消息，需要记忆
  middleware: [
    summarizationMiddleware({
      model,                     // 用哪个模型生成摘要
      trigger: { messages: 6 },  // 消息数超过 6 就触发
      keep: { messages: 2 },     // 摘要后保留最近 2 条
    }),
  ],
});

const config = { configurable: { thread_id: "demo" } };
const turns = [
  "我叫小明，是一名后端工程师。",
  "我最喜欢的语言是 Go。",
  "我正在做一个 LangChain 的学习项目。",
  "我养了一只叫豆豆的猫。",
];
for (const t of turns) {
  await agent.invoke({ messages: [{ role: "user", content: t }] }, config);
}

const res = await agent.invoke(
  { messages: [{ role: "user", content: "复述一下你记得关于我的信息。" }] },
  config
);

console.log(res.messages.map((m) => m.type).join(" -> "));
// human -> ai -> human -> ai   ← 历史已被压缩

<role>
Context Extraction Assistant
</role>

<primary_objective>
Your sole objective in this task is to extract the highest quality/most relevant context from the conversation history below.
</primary_objective>

<objective_information>
You're nearing the total number of input tokens you can accept, so you must extract the highest quality/most relevant pieces of information from your conversation history.
This context will then overwrite the conversation history presented below. Because of this, ensure the context you extract is only the most important information to your overall goal.
</objective_information>

<instructions>
The conversation history below will be replaced with the context you extract in this step. Because of this, you must do your very best to extract and record all of the most important context from the conversation history.
You want to ensure that you don't repeat any actions you've already completed, so the context you extract from the conversation history should be focused on the most important information to your overall goal.
</instructions>

The user will message you with the full message history you'll be extracting context from, to then replace. Carefully read over it all, and think deeply about what information is most important to your overall goal that should be saved:

With all of this in mind, please carefully read over the entire conversation history, and extract the most important and relevant context to replace it so that you can free up space in the conversation history.
Respond ONLY with the extracted context. Do not include any additional information, or text before or after the extracted context.

<messages>
Messages to summarize:
{messages}
</messages>

import { createAgent, tool, humanInTheLoopMiddleware } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
import { z } from "zod";

const sendEmail = tool(
  ({ to, subject }) => `邮件已发送给 ${to}，主题「${subject}」`,
  {
    name: "send_email",
    description: "发送邮件（敏感操作，需要人工审批）",
    schema: z.object({ to: z.string(), subject: z.string() }),
  }
);

const agent = createAgent({
  model,
  tools: [sendEmail],
  checkpointer: new MemorySaver(),   // HITL 必须挂 checkpointer
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: { allowedDecisions: ["approve", "edit", "reject"] },
      },
    }),
  ],
});

const config = { configurable: { thread_id: "hitl" } };
const res = await agent.invoke(
  { messages: [{ role: "user", content: "请发邮件给 boss@example.com，主题：周报" }] },
  config
);

if (res.__interrupt__) {
  const request = res.__interrupt__[0].value;
  console.log(request.actionRequests[0].args);          // { to: "boss@example.com", subject: "周报" }
  console.log(request.reviewConfigs[0].allowedDecisions); // ["approve","edit","reject"]
}

import { Command } from "@langchain/langgraph";

const resumed = await agent.invoke(
  new Command({
    resume: {
      decisions: [
        {
          type: "edit",
          editedAction: {
            name: "send_email",
            args: { to: "boss@example.com", subject: "【修改后】周报" },
          },
        },
      ],
    },
  }),
  config
);

console.log(resumed.messages.find((m) => m.type === "tool").content);
// 邮件已发送给 boss@example.com，主题「【修改后】周报」

import { createAgent, piiMiddleware } from "langchain";

const agent = createAgent({
  model,
  tools: [],
  middleware: [
    piiMiddleware("email", { strategy: "redact" }),
    piiMiddleware("credit_card", { strategy: "mask" }),
  ],
});

const res = await agent.invoke({
  messages: [
    {
      role: "user",
      content:
        "我的邮箱是 zhangsan@example.com，信用卡号是 4111 1111 1111 1111，请帮我看看。",
    },
  ],
});

console.log(res.messages[0].content);
// "我的邮箱是 [REDACTED_EMAIL]，信用卡号是 ****-****-****-1111，请帮我看看。"

piiMiddleware("api_key", {
  detector: "sk-[a-zA-Z0-9]{32}",   // 正则字符串
  strategy: "block",
});

import { createAgent, todoListMiddleware } from "langchain";

const agent = createAgent({
  model,
  tools: [],
  middleware: [todoListMiddleware()],
});

const res = await agent.invoke({
  messages: [
    { role: "user", content: "帮我规划一个去北京的三日游，请把步骤拆成待办清单。" },
  ],
});

console.log(res.todos);
// [
//   { content: "确定出行日期、人数、预算和住宿偏好", status: "in_progress" },
//   { content: "预订往返交通（机票/高铁）", status: "pending" },
//   ...
// ]

from langchain.agents import create_agent
from langchain.agents.middleware import (
    SummarizationMiddleware,
    HumanInTheLoopMiddleware,
    PIIMiddleware,
    TodoListMiddleware,
)
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="gpt-5.5",
    tools=[],
    checkpointer=InMemorySaver(),
    middleware=[
        SummarizationMiddleware(
            model="gpt-5.4-mini",
            trigger=("messages", 6),   # 元组表示单个阈值；也可用 {"tokens": 4000, "messages": 10}
            keep=("messages", 2),
        ),
    ],
)

from langgraph.types import Command

agent = create_agent(
    model="gpt-5.5",
    tools=[send_email],
    checkpointer=InMemorySaver(),
    middleware=[
        HumanInTheLoopMiddleware(
            interrupt_on={
                "send_email": {"allowed_decisions": ["approve", "edit", "reject"]},
            }
        ),
    ],
)

result = agent.invoke({"messages": [...]}, {"configurable": {"thread_id": "hitl"}})
if result.get("__interrupt__"):
    agent.invoke(
        Command(resume={"decisions": [{
            "type": "edit",
            "edited_action": {"name": "send_email", "args": {"to": "...", "subject": "..."}},
        }]}),
        {"configurable": {"thread_id": "hitl"}},
    )

agent = create_agent(
    model="gpt-5.5",
    tools=[],
    middleware=[
        PIIMiddleware("email", strategy="redact", apply_to_input=True),
        PIIMiddleware("credit_card", strategy="mask", apply_to_input=True),
    ],
)

agent = create_agent(model="gpt-5.5", tools=[...], middleware=[TodoListMiddleware()])
result = agent.invoke({"messages": [{"role": "user", "content": "帮我规划..."}]})
print(result["todos"])