create-langgraph-app 1.2.0 → 1.4.0

package/README.md

@@ -11,7 +11,7 @@ npx create-langgraph-app
 ## What it does
 
 1. Asks for your project name
-2. Lets you pick an LLM provider (OpenAI, Anthropic, Google, Groq, Ollama)
+2. Lets you pick an LLM provider (OpenAI, Anthropic, Google, Groq, DeepSeek, Ollama)
 3. Lets you select which agent patterns to include:
    - **Supervisor** — central coordinator + worker agents
    - **Swarm** — peer-to-peer agent handoffs

package/dist/create.js

@@ -52,6 +52,7 @@ const PROVIDERS = {
     google: { envKey: "GOOGLE_API_KEY", defaultModel: "gemini-2.0-flash" },
     groq: { envKey: "GROQ_API_KEY", defaultModel: "llama-3.3-70b-versatile" },
     ollama: { envKey: "", defaultModel: "llama3.2" },
+    deepseek: { envKey: "DEEPSEEK_API_KEY", defaultModel: "deepseek-v4-flash" },
 };
 function generateEnv(config) {
     const prov = PROVIDERS[config.provider];
@@ -67,7 +68,9 @@ function generateEnv(config) {
     else {
         lines.push(`# No API key needed for ${config.provider}`);
     }
-    lines.push(``, `# Model (optional — defaults to ${prov.defaultModel})`, `# LLM_MODEL=${prov.defaultModel}`, `LLM_TEMPERATURE=0`, ``, `PORT=3000`, ``, `# LangSmith tracing (optional)`, `# LANGCHAIN_TRACING_V2=true`, `# LANGSMITH_API_KEY=`, `# LANGSMITH_PROJECT=${config.name}`);
+    lines.push(``, `# Model (optional — defaults to ${prov.defaultModel})`, `# LLM_MODEL=${prov.defaultModel}`, `LLM_TEMPERATURE=0`, ``, ...(config.provider === "deepseek"
+        ? [`# DeepSeek reasoning mode (optional — "disabled" | "enabled")`, `# DEEPSEEK_THINKING=disabled`, ``]
+        : []), `PORT=3000`, ``, `# LangSmith tracing (optional)`, `# LANGCHAIN_TRACING_V2=true`, `# LANGSMITH_API_KEY=`, `# LANGSMITH_PROJECT=${config.name}`);
     return lines.join("\n") + "\n";
 }
 function generatePackageJson(config) {
@@ -90,6 +93,7 @@ function generatePackageJson(config) {
         google: "@langchain/google-genai",
         groq: "@langchain/groq",
         ollama: "@langchain/ollama",
+        deepseek: "@langchain/deepseek",
     };
     deps[provPkg[config.provider]] = "latest";
     const pkg = {
@@ -101,6 +105,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))),
@@ -126,13 +131,13 @@ function generateTsConfig() {
             types: ["node"],
             outDir: "dist",
         },
-        include: ["src"],
+        include: ["src", "tests"],
     }, null, 2) + "\n";
 }
 function generateEnvConfig(config) {
     return `import "dotenv/config";
 
-const VALID_PROVIDERS = ["openai", "anthropic", "google", "groq", "ollama"] as const;
+const VALID_PROVIDERS = ["openai", "anthropic", "google", "groq", "ollama", "deepseek"] as const;
 export type LlmProvider = (typeof VALID_PROVIDERS)[number];
 
 function resolveProvider(): LlmProvider {
@@ -149,6 +154,7 @@ const API_KEY_MAP: Record<LlmProvider, string> = {
   google: "GOOGLE_API_KEY",
   groq: "GROQ_API_KEY",
   ollama: "",
+  deepseek: "DEEPSEEK_API_KEY",
 };
 
 export const LLM_PROVIDER = resolveProvider();
@@ -161,6 +167,9 @@ if (requiredKey && !process.env[requiredKey]) {
 
 export const LLM_MODEL = process.env.LLM_MODEL || undefined;
 export const LLM_TEMPERATURE = Number(process.env.LLM_TEMPERATURE ?? 0);
+// Uses || rather than ?? so an empty DEEPSEEK_THINKING= in .env falls back
+// to "disabled" instead of sending an invalid thinking type to the API.
+export const DEEPSEEK_THINKING = process.env.DEEPSEEK_THINKING || "disabled";
 export const PORT = Number(process.env.PORT ?? 3000);
 `;
 }
@@ -172,11 +181,15 @@ const PROVIDER_LLM = {
     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" },
+    deepseek: { pkg: "@langchain/deepseek", className: "ChatDeepSeek", modelArg: "model", defaultModel: "deepseek-v4-flash", extraArgs: 'modelKwargs: { thinking: { type: DEEPSEEK_THINKING } }' },
 };
 function generateLlmConfig(config) {
     const p = PROVIDER_LLM[config.provider] ?? PROVIDER_LLM.openai;
+    const envImports = config.provider === "deepseek"
+        ? "LLM_MODEL, LLM_TEMPERATURE, DEEPSEEK_THINKING"
+        : "LLM_MODEL, LLM_TEMPERATURE";
     return `import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { LLM_MODEL, LLM_TEMPERATURE } from "./env";
+import { ${envImports} } from "./env";
 
 const DEFAULT_MODEL = "${p.defaultModel}";
 
@@ -190,7 +203,7 @@ async function createLlm(opts: LlmOptions = {}): Promise<BaseChatModel> {
   const temperature = opts.temperature ?? LLM_TEMPERATURE;
 
   const { ${p.className} } = await import("${p.pkg}");
-  return new ${p.className}({ ${p.modelArg}: model, temperature });
+  return new ${p.className}({ ${p.modelArg}: model, temperature${p.extraArgs ? `, ${p.extraArgs}` : ""} });
 }
 
 let _default: Promise<BaseChatModel> | undefined;
@@ -335,6 +348,252 @@ export function makeSupervisor({
 }
 `;
 }
+// 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 = [];
@@ -706,6 +965,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",
@@ -732,6 +996,7 @@ async function main() {
             { value: "anthropic", label: "Anthropic (Claude Sonnet)" },
             { value: "google", label: "Google (Gemini 2.0 Flash)" },
             { value: "groq", label: "Groq (Llama 3.3 70B)" },
+            { value: "deepseek", label: "DeepSeek (deepseek-v4-flash)" },
             { value: "ollama", label: "Ollama (local, no API key)" },
         ]);
         const patterns = await choose(rl, "Which patterns? (select multiple)", [

package/package.json

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