create-langgraph-app 1.1.0 → 1.3.0

package/dist/create.js

@@ -72,18 +72,14 @@ function generateEnv(config) {
 }
 function generatePackageJson(config) {
     const deps = {
-        "@langchain/core": "^1.1.48",
-        "@langchain/langgraph": "^1.3.2",
-        "@langchain/langgraph-supervisor": "^1.0.3",
+        "@langchain/core": "^1.2.3",
+        "@langchain/langgraph": "^1.4.8",
         "@langchain/mcp-adapters": "^1.1.3",
         dotenv: "^17.4.2",
-        fastify: "^5.8.5",
-        langchain: "^1.3.0",
+        fastify: "^5.10.0",
+        langchain: "^1.5.3",
         zod: "^4.4.3",
     };
-    if (config.patterns.includes("swarm")) {
-        deps["@langchain/langgraph-swarm"] = "^1.0.2";
-    }
     if (config.patterns.includes("rag")) {
         deps["@langchain/textsplitters"] = "^1.0.1";
     }
@@ -105,6 +101,7 @@ function generatePackageJson(config) {
             dev: "tsx src/index.ts",
             "dev:http": "tsx src/server.ts",
             test: "vitest run",
+            "test:watch": "vitest",
             typecheck: "tsc --noEmit",
         },
         dependencies: Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b))),
@@ -130,7 +127,7 @@ function generateTsConfig() {
             types: ["node"],
             outDir: "dist",
         },
-        include: ["src"],
+        include: ["src", "tests"],
     }, null, 2) + "\n";
 }
 function generateEnvConfig(config) {
@@ -219,50 +216,372 @@ export function getLlm(opts?: LlmOptions): Promise<BaseChatModel> {
 `;
 }
 function generateAgentFactory() {
-    return `import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import type { StructuredToolInterface } from "@langchain/core/tools";
-import { createReactAgent, type CreateReactAgentParams } from "@langchain/langgraph/prebuilt";
+    return `import { createAgent, type ResponseFormat, type TypedToolStrategy } from "langchain";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+
+type CreateAgentParams = Parameters<typeof createAgent>[0];
 
 export interface MakeAgentParams {
   name: string;
   llm: BaseChatModel;
-  tools?: StructuredToolInterface[];
+  tools?: CreateAgentParams["tools"];
   system?: string;
-  responseFormat?: CreateReactAgentParams["responseFormat"];
+  responseFormat?: ResponseFormat | TypedToolStrategy<Record<string, unknown>>;
+  /**
+   * Only the outermost agent of a multi-agent setup should get a
+   * checkpointer — subagents inherit it at runtime, which is what lets
+   * interrupt() calls bubble up to the top-level graph.
+   */
+  checkpointer?: BaseCheckpointSaver;
 }
 
-export function makeAgent({ name, llm, tools = [], system, responseFormat }: MakeAgentParams) {
-  return createReactAgent({
+/** Wraps LangChain's createAgent with a simpler interface. */
+export function makeAgent({
+  name,
+  llm,
+  tools = [],
+  system,
+  responseFormat,
+  checkpointer,
+}: MakeAgentParams) {
+  return createAgent({
     name,
-    llm,
+    model: llm,
     tools,
-    ...(system ? { prompt: system } : {}),
+    ...(system ? { systemPrompt: system } : {}),
     ...(responseFormat ? { responseFormat } : {}),
+    ...(checkpointer ? { checkpointer } : {}),
   });
 }
+
+export type AgentGraph = ReturnType<typeof makeAgent>;
 `;
 }
 function generateSupervisorHelper() {
-    return `import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import type { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { createSupervisor } from "@langchain/langgraph-supervisor";
-import { MemorySaver, InMemoryStore } from "@langchain/langgraph";
+    return `import { z } from "zod";
+import { tool } from "@langchain/core/tools";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { MemorySaver } from "@langchain/langgraph";
+import { makeAgent, type AgentGraph } from "./factory";
 
-type SupervisorParams = Parameters<typeof createSupervisor>[0];
+/**
+ * Supervisor via the "subagents" pattern: a main agent coordinates workers
+ * by calling them as tools. Subagents are stateless and run in isolated
+ * context windows; only the supervisor gets a checkpointer, so interrupt()
+ * inside a subagent tool pauses the whole graph.
+ */
+
+export interface SubagentSpec {
+  /** Tool name the supervisor calls, e.g. "math_expert". */
+  name: string;
+  /** Tells the supervisor's model when to delegate to this agent. */
+  description: string;
+  agent: AgentGraph;
+}
+
+/** Wraps a compiled agent as a tool the supervisor can call. */
+export function subagentTool({ name, description, agent }: SubagentSpec) {
+  return tool(
+    async ({ task }) => {
+      const result = await agent.invoke({
+        messages: [{ role: "user", content: task }],
+      });
+      const last = result.messages.at(-1);
+      if (!last) return "(no response)";
+      return typeof last.content === "string"
+        ? last.content
+        : JSON.stringify(last.content);
+    },
+    {
+      name,
+      description,
+      schema: z.object({
+        task: z
+          .string()
+          .describe("A self-contained task with all context the agent needs"),
+      }),
+    }
+  );
+}
 
-export interface MakeSupervisorParams extends SupervisorParams {
+export interface MakeSupervisorParams {
+  subagents: SubagentSpec[];
+  llm: BaseChatModel;
+  supervisorName?: string;
+  prompt?: string;
   checkpointer?: BaseCheckpointSaver;
-  store?: BaseStore;
 }
 
-export function makeSupervisor({ checkpointer, store, ...params }: MakeSupervisorParams) {
-  return createSupervisor(params).compile({
+export function makeSupervisor({
+  subagents,
+  llm,
+  supervisorName = "supervisor",
+  prompt,
+  checkpointer,
+}: MakeSupervisorParams) {
+  const defaultPrompt =
+    "You coordinate a team of specialists. Delegate work to them via " +
+    \`your tools (\${subagents.map((s) => s.name).join(", ")}) and answer \` +
+    "the user only once the delegated work is done.";
+
+  return makeAgent({
+    name: supervisorName,
+    llm,
+    tools: subagents.map(subagentTool),
+    system: prompt ?? defaultPrompt,
     checkpointer: checkpointer ?? new MemorySaver(),
-    store: store ?? new InMemoryStore(),
   });
 }
 `;
 }
+// Maps a selected pattern to the app it generates, so the server and demos
+// only reference files that actually exist.
+const PATTERN_APPS = {
+    supervisor: { route: "supervisor", fn: "createSupervisorApp", path: "./apps/supervisor" },
+    swarm: { route: "swarm", fn: "createSwarmApp", path: "./apps/swarm" },
+    hitl: { route: "interrupt", fn: "createInterruptApp", path: "./apps/interrupt" },
+    structured: { route: "analyst", fn: "createAnalystApp", path: "./apps/analyst" },
+    rag: { route: "rag", fn: "createRagApp", path: "./apps/rag" },
+};
+function selectedApps(config) {
+    return config.patterns.map((p) => PATTERN_APPS[p]).filter(Boolean);
+}
+function generateServer(config) {
+    const apps = selectedApps(config);
+    const imports = apps.map((a) => `import { ${a.fn} } from "${a.path}";`).join("\n");
+    const entries = apps.map((a) => `    "${a.route}": asApp(await ${a.fn}()),`).join("\n");
+    return `import "./config/env";
+import { fastify, type FastifyError, type FastifyReply, type FastifyRequest } from "fastify";
+import { Command } from "@langchain/langgraph";
+import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
+import { PORT } from "./config/env";
+${imports}
+
+// The apps are a mix of agents and graphs whose generic types don't unify;
+// this is the structural slice the routes actually need.
+interface AppGraph {
+  invoke(input: unknown, config?: unknown): Promise<{ messages: BaseMessage[] } & Record<string, unknown>>;
+  stream(input: unknown, config?: unknown): Promise<AsyncIterable<[unknown, { langgraph_node?: string } | undefined]>>;
+  getState(config: unknown): Promise<{ values?: unknown; next?: string[]; tasks?: unknown[] } | undefined>;
+}
+const asApp = (g: unknown) => g as AppGraph;
+
+function httpError(status: number, message: string) {
+  return Object.assign(new Error(message), { statusCode: status });
+}
+
+/** Reject malformed bodies before they reach the agent. */
+function validateMessages(raw: unknown): { role: string; content: string }[] {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) throw httpError(400, '"messages" must be an array');
+  return raw.map((m, i) => {
+    const { role, content } = (m ?? {}) as Record<string, unknown>;
+    if (typeof role !== "string" || typeof content !== "string") {
+      throw httpError(400, \`messages[\${i}] needs string "role" and "content"\`);
+    }
+    return { role, content };
+  });
+}
+
+const server = fastify({ logger: false });
+
+server.setErrorHandler(async (error: FastifyError, _req: FastifyRequest, reply: FastifyReply) => {
+  const status = error.statusCode ?? 500;
+  return reply.status(status).send({ error: error.message });
+});
+
+async function start() {
+  const apps: Record<string, AppGraph> = {
+${entries}
+  };
+
+  const getApp = (name: string) => {
+    const app = apps[name];
+    if (!app) throw httpError(404, \`Unknown app: "\${name}". Available: \${Object.keys(apps).join(", ")}\`);
+    return app;
+  };
+
+  server.post<{ Params: { app: string } }>("/:app/invoke", async (req, reply) => {
+    const app = getApp(req.params.app);
+    const body = (req.body ?? {}) as { messages?: unknown; thread_id?: string };
+    const messages = validateMessages(body.messages);
+    const thread_id = body.thread_id ?? "default";
+
+    const result = await app.invoke({ messages }, { configurable: { thread_id } });
+    const last = result.messages.at(-1);
+    return reply.send({
+      messages: result.messages,
+      structuredResponse: (result as Record<string, unknown>).structuredResponse ?? null,
+      lastMessage: typeof last?.content === "string" ? last.content : JSON.stringify(last?.content),
+    });
+  });
+
+  server.post<{ Params: { app: string } }>("/:app/stream", async (req, reply) => {
+    const app = getApp(req.params.app);
+    const body = (req.body ?? {}) as { messages?: unknown; thread_id?: string };
+    const messages = validateMessages(body.messages);
+    const thread_id = body.thread_id ?? "default";
+
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+    const send = (e: unknown) => reply.raw.write(\`data: \${JSON.stringify(e)}\\n\\n\`);
+
+    try {
+      const stream = await app.stream({ messages }, { configurable: { thread_id }, streamMode: "messages" });
+      for await (const [chunk, metadata] of stream) {
+        if (chunk instanceof AIMessageChunk) {
+          send({ type: "token", content: chunk.content, node: metadata?.langgraph_node ?? "unknown" });
+        }
+      }
+      send({ type: "done" });
+    } catch (err) {
+      send({ type: "error", content: err instanceof Error ? err.message : "Stream failed" });
+    } finally {
+      reply.raw.end();
+    }
+  });
+
+  server.post<{ Params: { app: string } }>("/:app/resume", async (req, reply) => {
+    const app = getApp(req.params.app);
+    const body = (req.body ?? {}) as { thread_id?: string; decision?: string };
+    if (body.decision === undefined) {
+      return reply.status(400).send({ error: '"decision" field is required' });
+    }
+    const result = await app.invoke(new Command({ resume: body.decision }), {
+      configurable: { thread_id: body.thread_id ?? "default" },
+    });
+    const last = result.messages.at(-1);
+    return reply.send({
+      messages: result.messages,
+      lastMessage: typeof last?.content === "string" ? last.content : JSON.stringify(last?.content),
+    });
+  });
+
+  server.get<{ Params: { app: string; threadId: string } }>("/:app/threads/:threadId", async (req, reply) => {
+    const app = getApp(req.params.app);
+    const state = await app.getState({ configurable: { thread_id: req.params.threadId } });
+    if (!state?.values) return reply.status(404).send({ error: "Thread not found" });
+    return reply.send({ values: state.values, next: state.next ?? [], tasks: state.tasks ?? [] });
+  });
+
+  server.get("/health", async () => ({ status: "ok", apps: Object.keys(apps) }));
+
+  // Container runtimes send SIGTERM on stop — drain instead of dying mid-request.
+  let shuttingDown = false;
+  for (const signal of ["SIGTERM", "SIGINT"] as const) {
+    process.on(signal, () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      server.close().then(() => process.exit(0)).catch(() => process.exit(1));
+    });
+  }
+
+  await server.listen({ port: PORT, host: "0.0.0.0" });
+  console.log(\`Server running at http://localhost:\${PORT}\`);
+  console.log(\`Apps: \${Object.keys(apps).join(", ")}\`);
+}
+
+start().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+`;
+}
+function generateScriptedModel() {
+    return `import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { AIMessage, type BaseMessage } from "@langchain/core/messages";
+import type { ChatResult } from "@langchain/core/outputs";
+
+/**
+ * A model that replays a queued list of responses, so tests can drive real
+ * graphs offline — no API key, no network, fully deterministic.
+ */
+export class ScriptedToolCallingModel extends BaseChatModel {
+  private queue: AIMessage[];
+
+  constructor(queue: AIMessage[]) {
+    super({});
+    this.queue = [...queue];
+  }
+
+  _llmType(): string {
+    return "scripted-tool-calling";
+  }
+
+  override bindTools(): this {
+    return this;
+  }
+
+  async _generate(_messages: BaseMessage[]): Promise<ChatResult> {
+    const message = this.queue.shift();
+    if (!message) throw new Error("Scripted model ran out of responses");
+    return { generations: [{ message, text: "" }] };
+  }
+}
+`;
+}
+function generateAgentTest(config) {
+    const hasSupervisor = config.patterns.includes("supervisor");
+    const supervisorTest = hasSupervisor
+        ? `
+  it("delegates to a subagent and returns its answer", async () => {
+    const llm = new ScriptedToolCallingModel([
+      // supervisor delegates
+      new AIMessage({
+        content: "",
+        tool_calls: [{ id: "c1", name: "worker", args: { task: "do the thing" } }],
+      }),
+      // subagent answers
+      new AIMessage("worker done"),
+      // supervisor wraps up
+      new AIMessage("All finished."),
+    ]);
+
+    const worker = makeAgent({ name: "worker", llm, tools: [] });
+    const app = await makeSupervisor({
+      subagents: [{ name: "worker", description: "Does the thing.", agent: worker }],
+      llm,
+      checkpointer: new MemorySaver(),
+    });
+
+    const result = await app.invoke(
+      { messages: [{ role: "user", content: "do the thing" }] },
+      { configurable: { thread_id: "t1" } }
+    );
+
+    expect(result.messages.at(-1)?.content).toBe("All finished.");
+    // the supervisor sees the subagent's final answer, not its internals
+    const toolMessages = result.messages.filter((m) => m.getType() === "tool");
+    expect(toolMessages).toHaveLength(1);
+    expect(toolMessages[0].content).toBe("worker done");
+  });
+`
+        : "";
+    const supervisorImports = hasSupervisor
+        ? `import { makeSupervisor } from "../src/agents/supervisor";\nimport { MemorySaver } from "@langchain/langgraph";\n`
+        : "";
+    return `import { describe, expect, it } from "vitest";
+import { AIMessage } from "@langchain/core/messages";
+import { makeAgent } from "../src/agents/factory";
+${supervisorImports}import { ScriptedToolCallingModel } from "./helpers/scripted-model";
+
+describe("agents", () => {
+  it("runs a single agent to a final answer", async () => {
+    const llm = new ScriptedToolCallingModel([new AIMessage("Hello there.")]);
+    const agent = makeAgent({ name: "assistant", llm, tools: [], system: "Be brief." });
+
+    const result = await agent.invoke({ messages: [{ role: "user", content: "hi" }] });
+
+    expect(result.messages.at(-1)?.content).toBe("Hello there.");
+  });
+${supervisorTest}});
+`;
+}
 // Pattern-specific: only files for selected patterns are generated
 function getPatternFiles(config) {
     const files = [];
@@ -303,8 +622,11 @@ export async function createSupervisorApp() {
   });
 
   return makeSupervisor({
-    agents: [math, writer], llm,
-    outputMode: "last_message",
+    subagents: [
+      { name: "math_expert", description: "Delegate calculations to the math expert.", agent: math },
+      { name: "writer", description: "Delegate writing. Include all facts the text should contain.", agent: writer },
+    ],
+    llm,
     supervisorName: "supervisor",
   });
 }
@@ -322,56 +644,131 @@ export async function createSupervisorApp() {
     if (config.patterns.includes("swarm")) {
         files.push({
             path: "src/agents/swarm.ts",
-            content: `import type { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { MessagesAnnotation, Annotation, MemorySaver } from "@langchain/langgraph";
-import { createSwarm } from "@langchain/langgraph-swarm";
+            content: `import { z } from "zod";
+import { AIMessage } from "@langchain/core/messages";
+import {
+  StateGraph,
+  StateSchema,
+  MessagesValue,
+  MemorySaver,
+  START,
+  END,
+} from "@langchain/langgraph";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import type { AgentGraph } from "./factory";
+
+/**
+ * Swarm via the "handoffs" pattern: each agent is a graph node, and handoff
+ * tools (see ./handoff.ts) jump between nodes while flipping activeAgent.
+ * activeAgent is checkpointed, so the conversation resumes with whichever
+ * agent last held it.
+ */
 
-export const SwarmState = Annotation.Root({
-  ...MessagesAnnotation.spec,
-  activeAgent: Annotation<string>(),
+export const SwarmState = new StateSchema({
+  messages: MessagesValue,
+  activeAgent: z.string().optional(),
 });
 
-type SwarmParams = Parameters<typeof createSwarm>[0];
+export type SwarmStateType = typeof SwarmState.State;
 
-export function makeSwarm({
-  agents, defaultActiveAgent, checkpointer,
-}: {
-  agents: SwarmParams["agents"];
+export interface SwarmAgentSpec {
+  /** Node name; handoff tools reference it as transfer_to_<name>. */
+  name: string;
+  agent: AgentGraph;
+}
+
+export interface MakeSwarmParams {
+  agents: SwarmAgentSpec[];
   defaultActiveAgent: string;
   checkpointer?: BaseCheckpointSaver;
-  store?: BaseStore;
-}) {
-  return createSwarm({ agents, defaultActiveAgent, stateSchema: SwarmState })
-    .compile({ checkpointer: checkpointer ?? new MemorySaver() });
+}
+
+export function makeSwarm({
+  agents,
+  defaultActiveAgent,
+  checkpointer,
+}: MakeSwarmParams) {
+  const names = agents.map((a) => a.name);
+
+  const routeToActive = (state: SwarmStateType) =>
+    state.activeAgent ?? defaultActiveAgent;
+
+  // After an agent runs: done if it answered (no pending tool calls);
+  // otherwise a handoff moved activeAgent, so continue there.
+  const routeAfterAgent = (state: SwarmStateType) => {
+    const last = state.messages.at(-1);
+    if (last && AIMessage.isInstance(last) && !last.tool_calls?.length) {
+      return END;
+    }
+    return state.activeAgent ?? defaultActiveAgent;
+  };
+
+  // Node names are only known at runtime, so the graph is built with
+  // string keys and the routers are cast to the node-name union.
+  let builder = new StateGraph(SwarmState) as StateGraph<
+    typeof SwarmState,
+    SwarmStateType
+  >;
+  for (const { name, agent } of agents) {
+    builder = builder.addNode(name, async (state: SwarmStateType) =>
+      agent.invoke(state)
+    ) as typeof builder;
+  }
+
+  builder.addConditionalEdges(START, routeToActive as never, names as never);
+  for (const name of names) {
+    builder.addConditionalEdges(
+      name as never,
+      routeAfterAgent as never,
+      [...names, END] as never
+    );
+  }
+
+  return builder.compile({
+    checkpointer: checkpointer ?? new MemorySaver(),
+  });
 }
 `,
         });
         files.push({
             path: "src/agents/handoff.ts",
             content: `import { z } from "zod";
-import { ToolMessage } from "@langchain/core/messages";
-import { tool } from "@langchain/core/tools";
-import { Command, MessagesAnnotation, getCurrentTaskInput } from "@langchain/langgraph";
+import { tool, type ToolRuntime } from "@langchain/core/tools";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { Command } from "@langchain/langgraph";
+import type { SwarmStateType } from "./swarm";
 
+/**
+ * Handoff tool for the handoffs pattern. Returns a Command targeting the
+ * PARENT graph: it flips activeAgent and jumps to the target agent's node.
+ * The calling agent's last AI message (the one containing this tool call)
+ * plus a ToolMessage are copied into parent state so the conversation
+ * history stays well-formed.
+ */
 export function createHandoffTool({ agentName, description }: { agentName: string; description?: string }) {
-  const toolName = \`transfer_to_\${agentName.replace(/\\s+/g, "_").toLowerCase()}\`;
-
   return tool(
-    async (_args, cfg) => {
-      const state = getCurrentTaskInput() as (typeof MessagesAnnotation)["State"];
-      const messages = state.messages ?? [];
-      const tm = new ToolMessage({
+    async (_, runtime: ToolRuntime<SwarmStateType>) => {
+      const lastAiMessage = [...(runtime.state.messages ?? [])]
+        .reverse()
+        .find(AIMessage.isInstance);
+      const transferMessage = new ToolMessage({
         content: \`Transferred to \${agentName}\`,
-        name: toolName,
-        tool_call_id: cfg.toolCall.id,
+        tool_call_id: runtime.toolCallId ?? "",
       });
       return new Command({
         goto: agentName,
+        update: {
+          activeAgent: agentName,
+          messages: [lastAiMessage, transferMessage].filter(Boolean),
+        },
         graph: Command.PARENT,
-        update: { messages: messages.concat(tm), activeAgent: agentName },
       });
     },
-    { name: toolName, description: description ?? \`Ask \${agentName} for help\`, schema: z.object({}) }
+    {
+      name: \`transfer_to_\${agentName}\`,
+      description: description ?? \`Transfer the conversation to \${agentName}.\`,
+      schema: z.object({}),
+    }
   );
 }
 `,
@@ -383,7 +780,7 @@ import { z } from "zod";
 import { tool } from "@langchain/core/tools";
 import { makeAgent } from "../agents/factory";
 import { createHandoffTool } from "../agents/handoff";
-import { makeSwarm, type SwarmState } from "../agents/swarm";
+import { makeSwarm } from "../agents/swarm";
 
 const add = tool(async ({ a, b }) => String(a + b), {
   name: "add", description: "Add two numbers",
@@ -411,7 +808,10 @@ export async function createSwarmApp() {
   });
 
   return makeSwarm({
-    agents: [alice, bob] as any,
+    agents: [
+      { name: "alice", agent: alice },
+      { name: "bob", agent: bob },
+    ],
     defaultActiveAgent: "alice",
   });
 }
@@ -431,10 +831,9 @@ export async function createSwarmApp() {
             path: "src/apps/interrupt.ts",
             content: `import { z } from "zod";
 import { tool } from "@langchain/core/tools";
-import { interrupt } from "@langchain/langgraph";
+import { interrupt, MemorySaver } from "@langchain/langgraph";
 import { getLlm } from "../config/llm";
 import { makeAgent } from "../agents/factory";
-import { makeSupervisor } from "../agents/supervisor";
 
 const deleteRecord = tool(
   async (args) => {
@@ -457,16 +856,13 @@ const deleteRecord = tool(
 export async function createInterruptApp() {
   const llm = await getLlm();
 
-  const dbAdmin = makeAgent({
+  // A single agent with a checkpointer — interrupt() inside delete_record
+  // pauses the graph; resume with Command({ resume: "yes" }) on the thread.
+  return makeAgent({
     name: "db_admin", llm,
     tools: [deleteRecord],
     system: "You are a database administrator.",
-  });
-
-  return makeSupervisor({
-    agents: [dbAdmin], llm,
-    outputMode: "last_message",
-    supervisorName: "interrupt_supervisor",
+    checkpointer: new MemorySaver(),
   });
 }
 `,
@@ -491,9 +887,10 @@ export async function createInterruptApp() {
         files.push({
             path: "src/apps/analyst.ts",
             content: `import { z } from "zod";
+import { toolStrategy } from "langchain";
+import { MemorySaver } from "@langchain/langgraph";
 import { getLlm } from "../config/llm";
 import { makeAgent } from "../agents/factory";
-import { makeSupervisor } from "../agents/supervisor";
 
 const SummarySchema = z.object({
   title: z.string(),
@@ -504,16 +901,14 @@ const SummarySchema = z.object({
 export async function createAnalystApp() {
   const llm = await getLlm();
 
-  const analyst = makeAgent({
+  // The structured result is returned on the structuredResponse key of the
+  // final state. toolStrategy works with every provider; models with native
+  // structured output support could use providerStrategy instead.
+  return makeAgent({
     name: "analyst", llm, tools: [],
     system: "Analyze text and produce structured summaries.",
-    responseFormat: SummarySchema,
-  });
-
-  return makeSupervisor({
-    agents: [analyst], llm,
-    outputMode: "last_message",
-    supervisorName: "analyst_supervisor",
+    responseFormat: toolStrategy(SummarySchema),
+    checkpointer: new MemorySaver(),
   });
 }
 `,
@@ -525,14 +920,15 @@ export async function createAnalystApp() {
     { messages: [{ role: "user", content: "Analyze: Revenue grew 25% but churn increased 8%." }] },
     { configurable: { thread_id: "analyst-demo" } }
   );
-  console.log("Result:", analysis.messages.at(-1)?.content);`);
+  const structured = (analysis as Record<string, unknown>).structuredResponse;
+  console.log("Result:", JSON.stringify(structured ?? analysis.messages.at(-1)?.content));`);
     }
     if (config.patterns.includes("rag")) {
         files.push({
             path: "src/apps/rag.ts",
-            content: `import { getLlm } from "../config/llm";
+            content: `import { MemorySaver } from "@langchain/langgraph";
+import { getLlm } from "../config/llm";
 import { makeAgent } from "../agents/factory";
-import { makeSupervisor } from "../agents/supervisor";
 // TODO: Add your vector store, embeddings, and retrieval tool here.
 // See the full starter kit for a complete RAG implementation:
 // https://github.com/ac12644/langgraph-starter-kit
@@ -540,15 +936,10 @@ import { makeSupervisor } from "../agents/supervisor";
 export async function createRagApp() {
   const llm = await getLlm();
 
-  const ragAgent = makeAgent({
+  return makeAgent({
     name: "rag_agent", llm, tools: [],
     system: "You are a knowledgeable assistant. Answer questions based on your knowledge.",
-  });
-
-  return makeSupervisor({
-    agents: [ragAgent], llm,
-    outputMode: "last_message",
-    supervisorName: "rag_supervisor",
+    checkpointer: new MemorySaver(),
   });
 }
 `,
@@ -562,6 +953,11 @@ export async function createRagApp() {
   );
   console.log("Result:", rag.messages.at(-1)?.content);`);
     }
+    // HTTP server — routes only the apps that were generated
+    files.push({ path: "src/server.ts", content: generateServer(config) });
+    // Tests — offline, no API key needed
+    files.push({ path: "tests/helpers/scripted-model.ts", content: generateScriptedModel() });
+    files.push({ path: "tests/agents.test.ts", content: generateAgentTest(config) });
     // Generate index.ts
     files.push({
         path: "src/index.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-langgraph-app",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Scaffold a new LangGraph multi-agent project in seconds",
   "type": "module",
   "bin": {