create-langgraph-app 1.0.0 → 1.2.0

package/dist/create.js

@@ -72,18 +72,14 @@ function generateEnv(config) {
 }
 function generatePackageJson(config) {
     const deps = {
-        "@langchain/core": "^1.1.39",
-        "@langchain/langgraph": "^1.2.7",
-        "@langchain/langgraph-supervisor": "^1.0.1",
+        "@langchain/core": "^1.2.3",
+        "@langchain/langgraph": "^1.4.8",
         "@langchain/mcp-adapters": "^1.1.3",
-        dotenv: "^17.4.0",
-        fastify: "^5.8.4",
-        langchain: "^1.3.0",
-        zod: "^4.3.6",
+        dotenv: "^17.4.2",
+        fastify: "^5.10.0",
+        langchain: "^1.5.3",
+        zod: "^4.4.3",
     };
-    if (config.patterns.includes("swarm")) {
-        deps["@langchain/langgraph-swarm"] = "^1.0.1";
-    }
     if (config.patterns.includes("rag")) {
         deps["@langchain/textsplitters"] = "^1.0.1";
     }
@@ -109,10 +105,10 @@ function generatePackageJson(config) {
         },
         dependencies: Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b))),
         devDependencies: {
-            "@types/node": "^25.5.2",
-            tsx: "^4.21.0",
-            typescript: "^6.0.2",
-            vitest: "^4.1.2",
+            "@types/node": "^25.9.1",
+            tsx: "^4.22.4",
+            typescript: "^6.0.3",
+            vitest: "^4.1.8",
         },
     };
     return JSON.stringify(pkg, null, 2) + "\n";
@@ -157,6 +153,7 @@ const API_KEY_MAP: Record<LlmProvider, string> = {
 
 export const LLM_PROVIDER = resolveProvider();
 
+// Fail fast: validate the selected provider's key at startup.
 const requiredKey = API_KEY_MAP[LLM_PROVIDER];
 if (requiredKey && !process.env[requiredKey]) {
   throw new Error(\`\${requiredKey} is required for provider "\${LLM_PROVIDER}" but not set in .env\`);
@@ -167,127 +164,173 @@ export const LLM_TEMPERATURE = Number(process.env.LLM_TEMPERATURE ?? 0);
 export const PORT = Number(process.env.PORT ?? 3000);
 `;
 }
-function generateLlmConfig() {
-    return `import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { LLM_PROVIDER, LLM_MODEL, LLM_TEMPERATURE } from "./env";
-
-const DEFAULTS: Record<string, string> = {
-  openai: "gpt-4o-mini",
-  anthropic: "claude-sonnet-4-20250514",
-  google: "gemini-2.0-flash",
-  groq: "llama-3.3-70b-versatile",
-  ollama: "llama3.2",
+// Per-provider class + constructor shape. The generated llm.ts only imports the
+// provider that was selected, so the scaffold depends on a single LLM SDK.
+const PROVIDER_LLM = {
+    openai: { pkg: "@langchain/openai", className: "ChatOpenAI", modelArg: "modelName", defaultModel: "gpt-4o-mini" },
+    anthropic: { pkg: "@langchain/anthropic", className: "ChatAnthropic", modelArg: "modelName", defaultModel: "claude-sonnet-4-20250514" },
+    google: { pkg: "@langchain/google-genai", className: "ChatGoogleGenerativeAI", modelArg: "model", defaultModel: "gemini-2.0-flash" },
+    groq: { pkg: "@langchain/groq", className: "ChatGroq", modelArg: "model", defaultModel: "llama-3.3-70b-versatile" },
+    ollama: { pkg: "@langchain/ollama", className: "ChatOllama", modelArg: "model", defaultModel: "llama3.2" },
 };
+function generateLlmConfig(config) {
+    const p = PROVIDER_LLM[config.provider] ?? PROVIDER_LLM.openai;
+    return `import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { LLM_MODEL, LLM_TEMPERATURE } from "./env";
 
-function createLlm(): BaseChatModel {
-  const model = LLM_MODEL ?? DEFAULTS[LLM_PROVIDER] ?? DEFAULTS.openai;
-  const temperature = LLM_TEMPERATURE;
+const DEFAULT_MODEL = "${p.defaultModel}";
 
-  switch (LLM_PROVIDER) {
-    case "anthropic": {
-      const { ChatAnthropic } = require("@langchain/anthropic");
-      return new ChatAnthropic({ modelName: model, temperature });
-    }
-    case "google": {
-      const { ChatGoogleGenerativeAI } = require("@langchain/google-genai");
-      return new ChatGoogleGenerativeAI({ modelName: model, temperature });
-    }
-    case "groq": {
-      const { ChatGroq } = require("@langchain/groq");
-      return new ChatGroq({ modelName: model, temperature });
-    }
-    case "ollama": {
-      const { ChatOllama } = require("@langchain/ollama");
-      return new ChatOllama({ model, temperature });
-    }
-    default: {
-      const { ChatOpenAI } = require("@langchain/openai");
-      return new ChatOpenAI({ modelName: model, temperature });
-    }
-  }
+export interface LlmOptions {
+  model?: string;
+  temperature?: number;
+}
+
+async function createLlm(opts: LlmOptions = {}): Promise<BaseChatModel> {
+  const model = opts.model ?? LLM_MODEL ?? DEFAULT_MODEL;
+  const temperature = opts.temperature ?? LLM_TEMPERATURE;
+
+  const { ${p.className} } = await import("${p.pkg}");
+  return new ${p.className}({ ${p.modelArg}: model, temperature });
 }
 
-export const llm = createLlm();
+let _default: Promise<BaseChatModel> | undefined;
+
+/**
+ * Returns a chat model.
+ *
+ * Called with no options it returns a memoized, shared instance (nothing is
+ * constructed until first use). Pass options to build a distinct model, e.g. a
+ * cheap router and a strong worker:
+ *
+ *   const router = await getLlm({ model: "${p.defaultModel}" });
+ *   const worker = await getLlm({ model: "<a-stronger-model>" });
+ */
+export function getLlm(opts?: LlmOptions): Promise<BaseChatModel> {
+  if (!opts || Object.keys(opts).length === 0) {
+    _default ??= createLlm();
+    return _default;
+  }
+  return createLlm(opts);
+}
 `;
 }
 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";
+
+/**
+ * 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;
+}
 
-type SupervisorParams = Parameters<typeof createSupervisor>[0];
+/** 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(),
-  });
-}
-`;
-}
-function generateSupervisorApp() {
-    return `import { z } from "zod";
-import { tool } from "@langchain/core/tools";
-import { llm } from "./config/env";
-import { makeAgent } from "./agents/factory";
-import { makeSupervisor } from "./agents/supervisor";
-
-const add = tool(async ({ a, b }) => String(a + b), {
-  name: "add", description: "Add two numbers",
-  schema: z.object({ a: z.number(), b: z.number() }),
-});
-
-const multiply = tool(async ({ a, b }) => String(a * b), {
-  name: "multiply", description: "Multiply two numbers",
-  schema: z.object({ a: z.number(), b: z.number() }),
-});
-
-export function createApp() {
-  const math = makeAgent({
-    name: "math_expert", llm,
-    tools: [add, multiply],
-    system: "You are a math expert. Use tools to compute answers.",
-  });
-
-  const writer = makeAgent({
-    name: "writer", llm, tools: [],
-    system: "You write crisp, structured answers.",
-  });
-
-  return makeSupervisor({
-    agents: [math, writer], llm,
-    outputMode: "last_message",
-    supervisorName: "supervisor",
   });
 }
 `;
@@ -297,7 +340,7 @@ function getPatternFiles(config) {
     const files = [];
     // Always include core files
     files.push({ path: "src/config/env.ts", content: generateEnvConfig(config) });
-    files.push({ path: "src/config/llm.ts", content: generateLlmConfig() });
+    files.push({ path: "src/config/llm.ts", content: generateLlmConfig(config) });
     files.push({ path: "src/agents/factory.ts", content: generateAgentFactory() });
     files.push({ path: "src/agents/supervisor.ts", content: generateSupervisorHelper() });
     // Index file — imports vary by selected patterns
@@ -306,7 +349,7 @@ function getPatternFiles(config) {
     if (config.patterns.includes("supervisor")) {
         files.push({
             path: "src/apps/supervisor.ts",
-            content: `import { llm } from "../config/llm";
+            content: `import { getLlm } from "../config/llm";
 import { z } from "zod";
 import { tool } from "@langchain/core/tools";
 import { makeAgent } from "../agents/factory";
@@ -317,7 +360,9 @@ const add = tool(async ({ a, b }) => String(a + b), {
   schema: z.object({ a: z.number(), b: z.number() }),
 });
 
-export function createSupervisorApp() {
+export async function createSupervisorApp() {
+  const llm = await getLlm();
+
   const math = makeAgent({
     name: "math_expert", llm,
     tools: [add],
@@ -330,8 +375,11 @@ export 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",
   });
 }
@@ -339,7 +387,7 @@ export function createSupervisorApp() {
         });
         imports.push(`import { createSupervisorApp } from "./apps/supervisor";`);
         demos.push(`  console.log("=== Supervisor Demo ===");
-  const supervisorApp = createSupervisorApp();
+  const supervisorApp = await createSupervisorApp();
   const sup = await supervisorApp.invoke(
     { messages: [{ role: "user", content: "What is 10 + 15?" }] },
     { configurable: { thread_id: "demo" } }
@@ -349,68 +397,143 @@ export 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";
-
-export const SwarmState = Annotation.Root({
-  ...MessagesAnnotation.spec,
-  activeAgent: Annotation<string>(),
+            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 = 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({}),
+    }
   );
 }
 `,
         });
         files.push({
             path: "src/apps/swarm.ts",
-            content: `import { llm } from "../config/llm";
+            content: `import { getLlm } from "../config/llm";
 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",
@@ -422,7 +545,9 @@ const multiply = tool(async ({ a, b }) => String(a * b), {
   schema: z.object({ a: z.number(), b: z.number() }),
 });
 
-export function createSwarmApp() {
+export async function createSwarmApp() {
+  const llm = await getLlm();
+
   const alice = makeAgent({
     name: "alice", llm,
     tools: [add, createHandoffTool({ agentName: "bob" })],
@@ -436,7 +561,10 @@ export function createSwarmApp() {
   });
 
   return makeSwarm({
-    agents: [alice, bob] as any,
+    agents: [
+      { name: "alice", agent: alice },
+      { name: "bob", agent: bob },
+    ],
     defaultActiveAgent: "alice",
   });
 }
@@ -444,7 +572,7 @@ export function createSwarmApp() {
         });
         imports.push(`import { createSwarmApp } from "./apps/swarm";`);
         demos.push(`  console.log("\\n=== Swarm Demo ===");
-  const swarmApp = createSwarmApp();
+  const swarmApp = await createSwarmApp();
   const swarm = await swarmApp.invoke(
     { messages: [{ role: "user", content: "add 5 and 7, then talk to bob and multiply by 3" }] },
     { configurable: { thread_id: "swarm-demo" } }
@@ -456,10 +584,9 @@ export function createSwarmApp() {
             path: "src/apps/interrupt.ts",
             content: `import { z } from "zod";
 import { tool } from "@langchain/core/tools";
-import { interrupt } from "@langchain/langgraph";
-import { llm } from "../config/llm";
+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) => {
@@ -479,17 +606,16 @@ const deleteRecord = tool(
   }
 );
 
-export function createInterruptApp() {
-  const dbAdmin = makeAgent({
+export async function createInterruptApp() {
+  const llm = await getLlm();
+
+  // 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(),
   });
 }
 `,
@@ -497,7 +623,7 @@ export function createInterruptApp() {
         imports.push(`import { Command } from "@langchain/langgraph";`);
         imports.push(`import { createInterruptApp } from "./apps/interrupt";`);
         demos.push(`  console.log("\\n=== Human-in-the-Loop Demo ===");
-  const interruptApp = createInterruptApp();
+  const interruptApp = await createInterruptApp();
   const hitlCfg = { configurable: { thread_id: "hitl-demo" } };
   await interruptApp.invoke(
     { messages: [{ role: "user", content: "delete record rec_2" }] },
@@ -514,9 +640,10 @@ export function createInterruptApp() {
         files.push({
             path: "src/apps/analyst.ts",
             content: `import { z } from "zod";
-import { llm } from "../config/llm";
+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(),
@@ -524,57 +651,55 @@ const SummarySchema = z.object({
   sentiment: z.enum(["positive", "negative", "neutral"]),
 });
 
-export function createAnalystApp() {
-  const analyst = makeAgent({
+export async function createAnalystApp() {
+  const llm = await getLlm();
+
+  // 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(),
   });
 }
 `,
         });
         imports.push(`import { createAnalystApp } from "./apps/analyst";`);
         demos.push(`  console.log("\\n=== Structured Output Demo ===");
-  const analystApp = createAnalystApp();
+  const analystApp = await createAnalystApp();
   const analysis = await analystApp.invoke(
     { 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 { llm } 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
 
-export function createRagApp() {
-  const ragAgent = makeAgent({
+export async function createRagApp() {
+  const llm = await getLlm();
+
+  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(),
   });
 }
 `,
         });
         imports.push(`import { createRagApp } from "./apps/rag";`);
         demos.push(`  console.log("\\n=== RAG Demo ===");
-  const ragApp = createRagApp();
+  const ragApp = await createRagApp();
   const rag = await ragApp.invoke(
     { messages: [{ role: "user", content: "What is RAG and how does it work?" }] },
     { configurable: { thread_id: "rag-demo" } }

package/package.json

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