LangGraph's missing layer
is EZGraph

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24

const replace = <T>(_: T, next: T): T => next;
const appendMessages = (cur: BaseMessage[], up: BaseMessage | BaseMessage[]) =>
  cur.concat(Array.isArray(up) ? up : [up]);

export const QuoteLanggraphState = Annotation.Root({
  phase: Annotation<Phase>({ reducer: replace, default: () => "driver" }),
  route: Annotation<Route>({ reducer: replace, default: () => "end" }),
  completed: Annotation<boolean>({ reducer: replace, default: () => false }),
  response: Annotation<string>({ reducer: replace, default: () => "" }),
  userInput: Annotation<string>({ reducer: replace, default: () => "" }),
  inputConsumed: Annotation<boolean>({ reducer: replace, default: () => false }),
  config: Annotation<Record<string, unknown>>({
    reducer: (cur, up) => ({ ...cur, ...up }),
    default: () => ({}),
  }),
  driver: Annotation<DriverProfile | undefined>({
    reducer: replace, default: () => undefined,
  }),
  // ...9 more domain channels, each with reducer + default...
  intakeMessages: Annotation<BaseMessage[], BaseMessage | BaseMessage[]>({
    reducer: appendMessages, default: () => [],
  }),
  // ...2 more message channels...
});

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21

export type QuoteGraphNodes = {
  DriverNode?: NodeStateValue<{ driver?: DriverProfile }>;
  VehicleNode?: NodeStateValue<{
    resolvedVehicleId?: string;
    vehicle?: VehicleUse;
  }>;
  HistoryNode?: NodeStateValue<{ history?: InsuranceHistory }>;
  CoverageNode?: NodeStateValue<{ coverage?: CoverageSelection }>;
  QuoteNode?: NodeStateValue<{
    tiers?: QuoteTier[];
    acceptedTier?: QuoteTierName;
    referenceNumber?: string;
  }>;
};

export const QuoteGraphState = createGraphStateAnnotation(
  DriverNode.id(),
  () => ({} as QuoteGraphNodes),
);

export type QuoteGraphStateType = typeof QuoteGraphState.State;

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28

private readonly driverTools = async (state) => {
  const call = latestToolCall(state.intakeMessages);
  if (!call) return { route: "end" };
  if (call.name === "terminate_session")
    return terminateUpdate("intakeMessages", call);
  if (call.name !== "capture_driver") {
    return invalidToolUpdate("intakeMessages", call,
      `Tool '${call.name}' is not available here.`, "driverAgent");
  }
  let parsed: z.infer<typeof captureDriverSchema>;
  try {
    parsed = captureDriverSchema.parse(call.args);
  } catch (error) {
    return invalidToolUpdate("intakeMessages", call, zodError(error), "driverAgent");
  }
  const reject = (e: string) =>
    invalidToolUpdate("intakeMessages", call, e, "driverAgent");

  // ...25 lines of actual driver validation...

  return {
    driver,
    intakeMessages: toolResult(call, { accepted: true, driver }),
    phase: "vehicle",
    response: "",
    route: "vehicleAgent",
  };
};

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11

export class DriverNode extends ConversationNode<QuoteGraphStateType> {
  @Tool("capture_driver")
  async captureDriver(input: DriverInput): Promise<ToolResponse> {
    // ...the same 25 lines of deterministic driver validation...
    const driver = validateDriver(input);
    if (!driver.ok) return stay(JSON.stringify(driver.error));

    this.saveState({ driver: driver.value });
    return go(VehicleNode);
  }
}

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11

return {
  presentMessages: toolResult(call, { accepted: true }),
  intakeMessages: new HumanMessage(
    "Review and update the coverage selections.",
  ),
  phase: "coverage",
  // Forward the customer's current message into the coverage stage.
  inputConsumed: false,
  response: "",
  route: "coverageAgent",
};

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6

this.graph.appendHistory(this.graph.historySpace(CoverageNode.id()), [
  new HumanMessage(this.graph.input(this.graph.graphState())),
]);
return go(CoverageNode).withToolFeedback(
  "Review and update the coverage selections.",
);

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20

return new StateGraph(QuoteLanggraphState)
  .addNode("driverAgent", this.driverAgent)
  .addNode("driverTools", this.driverTools)
  .addNode("vehicleAgent", this.vehicleAgent)
  .addNode("vehicleTools", this.vehicleTools)
  // ...6 more addNode calls...
  .addConditionalEdges(START, routeFromPhase, agentRoutes)
  .addConditionalEdges("driverAgent",
    (s) => afterAgent(s, "driver"), { driverTools: "driverTools", end: END })
  .addConditionalEdges("vehicleAgent",
    (s) => afterAgent(s, "vehicle"), { vehicleTools: "vehicleTools", end: END })
  // ...3 more agent branches...
  .addConditionalEdges("driverTools", routeAfterTools, agentRoutes)
  .addConditionalEdges("vehicleTools", routeAfterTools, agentRoutes)
  // ...3 more tool branches...
  .compile();

// Plus: the agentRoutes map, routeFromPhase(), afterAgent(),
// routeAfterTools(), a Route string union in another file, and
// 16 inline `route:` writes scattered across the tool nodes.

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13

protected buildGraph() {
  const graph = this.createStateGraph(QuoteGraphState);
  graph.registerTurnNodes(
    DriverNode,
    VehicleNode,
    HistoryNode,
    CoverageNode,
    QuoteNode,
    TerminateSessionNode,
  );
  graph.addEdge(TerminateSessionNode, END);
  return graph.compile();
}