Error while checkpoint

[Mrunmay8558]

Hello,

I'm encountering a TypeError when running my code:

TypeError: channels[k].fromCheckpoint is not a function
at emptyChannels (file:///D:/Full%20Stack/React/aiast/backend/node_modules/@langchain/langgraph/dist/channels/base.js:32:42)
at PregelLoop.initialize (file:///D:/Full%20Stack/React/aiast/backend/node_modules/@langchain/langgraph/dist/pregel/loop.js:198:26)
at async CompiledStateGraph._streamIterator (file:///D:/Full%20Stack/React/aiast/backend/node_modules/@langchain/langgraph/dist/pregel/index.js:458:20)
It looks like the fromCheckpoint function is not defined for channels[k]. This issue arises when executing the new.js file. Could anyone provide insights into why this function might be missing or how to resolve this problem?

Thanks for your help!

[hinthornw]

Please share code.

[Mrunmay8558]

Here is the JavaScript code where I'm encountering an error.

// Import required modules
import { ChatTogetherAI } from "@langchain/community/chat_models/togetherai";
import {
StateGraph,
Annotation,
NodeInterrupt,
MessagesAnnotation,
} from "@langchain/langgraph";

// Initialize the model
const model = new ChatTogetherAI({
model: "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
temperature: 0,
apiKey: "",
});

// Define the state annotation
const StateAnnotation = Annotation.Root({
...MessagesAnnotation.spec,
nextRepresentative: String,
refundAuthorized: Boolean,
});
// Define the initial support node
const initialSupport = async (state) => {
const SYSTEM_TEMPLATE = You are frontline support staff for LangCorp, a company that sells computers. Be concise in your responses. You can chat with customers and help them with basic questions, but if the customer is having a billing or technical problem, do not try to answer the question directly or gather information. Instead, immediately transfer them to the billing or technical team by asking the user to hold for a moment. Otherwise, just respond conversationally.;
const supportResponse = await model.invoke([
{ role: "system", content: SYSTEM_TEMPLATE },
...state.messages,
]);

const CATEGORIZATION_SYSTEM_TEMPLATE = You are an expert customer support routing system. Your job is to detect whether a customer support representative is routing a user to a billing team or a technical team, or if they are just responding conversationally.;
const CATEGORIZATION_HUMAN_TEMPLATE = The previous conversation is an interaction between a customer support representative and a user. Extract whether the representative is routing the user to a billing or technical team, or whether they are just responding conversationally. Respond with a JSON object containing a single key called "nextRepresentative" with one of the following values: If they want to route the user to the billing team, respond only with the word "BILLING". If they want to route the user to the technical team, respond only with the word "TECHNICAL". Otherwise, respond only with the word "RESPOND".;
const categorizationResponse = await model.invoke(
[
{ role: "system", content: CATEGORIZATION_SYSTEM_TEMPLATE },
...state.messages,
{ role: "user", content: CATEGORIZATION_HUMAN_TEMPLATE },
],
{
response_format: {
type: "json_object",
},
}
);
const categorizationOutput = JSON.parse(categorizationResponse.content);
return {
messages: supportResponse,
nextRepresentative: categorizationOutput.nextRepresentative,
};
};

// Define the billing support node
const billingSupport = async (state) => {
const SYSTEM_TEMPLATE = You are an expert billing support specialist for LangCorp, a company that sells computers. Help the user to the best of your ability, but be concise in your responses. You have the ability to authorize refunds, which you can do by transferring the user to another agent who will collect the required information. If you do, assume the other agent has all necessary information about the customer and their order. You do not need to ask the user for more information.;

let trimmedHistory = state.messages;
if (trimmedHistory.at(-1).role === "ai") {
trimmedHistory = trimmedHistory.slice(0, -1);
}

const billingRepResponse = await model.invoke([
{ role: "system", content: SYSTEM_TEMPLATE },
...trimmedHistory,
]);

const CATEGORIZATION_SYSTEM_TEMPLATE = Your job is to detect whether a billing support representative wants to refund the user.;
const CATEGORIZATION_HUMAN_TEMPLATE = The following text is a response from a customer support representative. Extract whether they want to refund the user or not. Respond with a JSON object containing a single key called "nextRepresentative" with one of the following values: If they want to refund the user, respond only with the word "REFUND". Otherwise, respond only with the word "RESPOND". Here is the text: ${billingRepResponse.content};
const categorizationResponse = await model.invoke(
[
{ role: "system", content: CATEGORIZATION_SYSTEM_TEMPLATE },
{ role: "user", content: CATEGORIZATION_HUMAN_TEMPLATE },
],
{
response_format: {
type: "json_object",
},
}
);
const categorizationOutput = JSON.parse(categorizationResponse.content);
return {
messages: billingRepResponse,
nextRepresentative: categorizationOutput.nextRepresentative,
};
};

// Define the technical support node
const technicalSupport = async (state) => {
const SYSTEM_TEMPLATE = You are an expert at diagnosing technical computer issues. You work for a company called LangCorp that sells computers. Help the user to the best of your ability, but be concise in your responses.;

let trimmedHistory = state.messages;
if (trimmedHistory.at(-1).role === "ai") {
trimmedHistory = trimmedHistory.slice(0, -1);
}

const response = await model.invoke([
{ role: "system", content: SYSTEM_TEMPLATE },
...trimmedHistory,
]);

return {
messages: response,
};
};

// Define the handle refund node
const handleRefund = async (state) => {
if (!state.refundAuthorized) {
console.log("--- HUMAN AUTHORIZATION REQUIRED FOR REFUND ---");
throw new NodeInterrupt("Human authorization required.");
}
return {
messages: {
role: "assistant",
content: "Refund processed!",
},
};
};

// Build the state graph
const builder = new StateGraph(StateAnnotation)
.addNode("initial_support", initialSupport)
.addNode("billing_support", billingSupport)
.addNode("technical_support", technicalSupport)
.addNode("handle_refund", handleRefund)
.addEdge("start", "initial_support")
.addConditionalEdges(
"initial_support",
async (state) => {
if (state.nextRepresentative === "BILLING") {
return "billing_support";
} else if (state.nextRepresentative === "TECHNICAL") {
return "technical_support";
} else {
return "end";
}
},
{
billing_support: "billing_support",
technical_support: "technical_support",
end: "end",
}
)
.addEdge("technical_support", "end")
.addConditionalEdges(
"billing_support",
async (state) => {
if (state.nextRepresentative === "REFUND") {
return "handle_refund";
} else {
return "end";
}
},
{
handle_refund: "handle_refund",
end: "end",
}
)
.addEdge("handle_refund", "end");

// Compile the graph
const graph = builder.compile();

const runGraph = async () => {
const stream = await graph.stream({
messages: [
{
role: "user",
content: "I've changed my mind and I want a refund for order #182818!",
},
],
});

for await (const value of stream) {
console.log("---STEP---");
console.log(value);
console.log("---END STEP---");
}
};

runGraph().catch(console.error);

[jacoblee93]

A bit late but:

const StateAnnotation = Annotation.Root({
...MessagesAnnotation.spec,
nextRepresentative: String,
refundAuthorized: Boolean,
});

should be:

const StateAnnotation = Annotation.Root({
...MessagesAnnotation.spec,
nextRepresentative: Annotation<String>,
refundAuthorized: Annotation<Boolean>,
});

There may be other issues too - are you using TypeScript?

[Mrunmay8558]

No i am using javascript