Add human-in-the-loop with the Functional API

import {
  Command,
  MemorySaver,
  entrypoint,
  interrupt,
  task,
} from "@langchain/langgraph";

const step1 = task("step1", async (inputQuery: string) => {
  // Append bar
  return `${inputQuery} bar`;
});

const humanFeedback = task("humanFeedback", async (inputQuery: string) => {
  // Append user input
  const feedback = interrupt(`Please provide feedback: ${inputQuery}`);
  return `${inputQuery} ${feedback}`;
});

const step3 = task("step3", async (inputQuery: string) => {
  // Append qux
  return `${inputQuery} qux`;
});

const checkpointer = new MemorySaver();

const workflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (inputQuery: string) => {
    const result1 = await step1(inputQuery);
    const result2 = await humanFeedback(result1);
    const result3 = await step3(result2);
    return result3;
  }
);

const config = { configurable: { thread_id: "1" } };

const stream = await workflow.streamEvents("foo", {
  ...config,
  version: "v3",
});
for await (const chunk of stream.values) {
  console.log(chunk);
}
// -> { __interrupt__: [{ value: 'Please provide feedback: foo bar', ... }] }

const resumed = await workflow.streamEvents(new Command({ resume: "baz" }), {
  ...config,
  version: "v3",
});
let last: unknown;
for await (const chunk of resumed.values) {
  console.log(chunk);
  last = chunk;
}
// -> 'foo bar baz qux'

import { ToolMessage } from "@langchain/core/messages";
import { ToolCall } from "@langchain/core/messages/tool";
import { interrupt } from "@langchain/langgraph";

type ToolCallReview =
  | { action: "continue"; data?: undefined }
  | { action: "update"; data: ToolCall["args"] }
  | { action: "feedback"; data: string };

function reviewToolCall(toolCall: ToolCall): ToolCall | ToolMessage {
  // Review a tool call, returning a validated version
  const humanReview = interrupt({
    question: "Is this correct?",
    tool_call: toolCall,
  }) as ToolCallReview;

  if (humanReview.action === "continue") {
    return toolCall;
  }
  if (humanReview.action === "update") {
    return { ...toolCall, args: humanReview.data };
  }
  if (humanReview.action === "feedback") {
    return new ToolMessage({
      content: humanReview.data,
      name: toolCall.name,
      tool_call_id: toolCall.id,
    });
  }

  throw new Error("Unknown review action");
}

import {
  AIMessage,
  BaseMessage,
  HumanMessage,
} from "@langchain/core/messages";
import {
  Command,
  MemorySaver,
  addMessages,
  entrypoint,
  getPreviousState,
  task,
} from "@langchain/langgraph";

const checkpointer = new MemorySaver();

const callModel = task("callModel", async (messages: BaseMessage[]) => {
  const last = messages[messages.length - 1];
  if (last instanceof ToolMessage) {
    return new AIMessage({ content: "Search complete." });
  }
  return new AIMessage({
    content: "",
    tool_calls: [
      {
        name: "search",
        args: { query: "weather" },
        id: "call_1",
        type: "tool_call",
      },
    ],
  });
});

const callTool = task("callTool", async (toolCall: ToolCall) => {
  return new ToolMessage({
    content: `result for ${JSON.stringify(toolCall.args)}`,
    name: toolCall.name,
    tool_call_id: toolCall.id,
  });
});

const agent = entrypoint(
  { checkpointer, name: "agent" },
  async (messages: BaseMessage[]): Promise<BaseMessage> => {
    const previous = getPreviousState<BaseMessage[]>();
    if (previous !== undefined) {
      messages = addMessages(previous, messages);
    }

    let modelResponse = await callModel(messages);
    while (true) {
      if (!modelResponse.tool_calls?.length) {
        break;
      }

      // Review tool calls
      const toolResults: ToolMessage[] = [];
      const toolCalls: ToolCall[] = [];
      const updatedToolCalls = [...modelResponse.tool_calls];

      for (let i = 0; i < modelResponse.tool_calls.length; i++) {
        const review = reviewToolCall(modelResponse.tool_calls[i]);
        if (review instanceof ToolMessage) {
          toolResults.push(review);
        } else {
          // is a validated tool call
          toolCalls.push(review);
          updatedToolCalls[i] = review;
        }
      }

      const toolCallsChanged = updatedToolCalls.some(
        (call, i) => call !== modelResponse.tool_calls?.[i]
      );
      if (toolCallsChanged) {
        modelResponse = new AIMessage({
          content: modelResponse.content,
          tool_calls: updatedToolCalls,
        });
      }

      // Execute remaining tool calls
      const remainingToolResults = await Promise.all(
        toolCalls.map((toolCall) => callTool(toolCall))
      );

      // Append to message list
      messages = addMessages(messages, [
        modelResponse,
        ...toolResults,
        ...remainingToolResults,
      ]);

      // Call model again
      modelResponse = await callModel(messages);
    }

    // Generate final response
    messages = addMessages(messages, modelResponse);
    return entrypoint.final({ value: modelResponse, save: messages });
  }
);

const config = { configurable: { thread_id: "2" } };

const stream = await agent.streamEvents(
  [new HumanMessage("What's the weather?")],
  { ...config, version: "v3" }
);
for await (const chunk of stream.values) {
  console.log(chunk);
}

const result = await agent.invoke(
  new Command({ resume: { action: "continue" } }),
  config
);
console.log(result);