langgraph-middleware 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jake Hon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,278 @@
+# langgraph-middleware
+
+[![npm version](https://img.shields.io/npm/v/langgraph-middleware.svg)](https://www.npmjs.com/package/langgraph-middleware)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org/)
+
+**English** | [中文](doc/README.zh.md)
+
+**langgraph-middleware** brings middleware-style utilities to LangGraph's `StateGraph` — add **before/after hooks**, **reusable inject modules**, **error catching**, and **observability callbacks** to your graph nodes with a clean chainable API.
+
+## ✨ Features
+
+| Method | Description |
+|--------|-------------|
+| `.middleware(name, before?, after?)` | Wraps a node with **before** / **after** hooks, forming a subgraph <br> Cannot be applied to the same node more than once <br> `before` hook **must not** return a `Command` (use the main node or `after` hook for Command-based routing) |
+| `.inject(...modules)` | Registers reusable structure modules executed before `compile()` |
+| `.observe(callbacks, ...nodes?)` | Attaches LangChain `BaseCallbackHandler` instances for tracing/logging |
+| `.catch(handler, ...nodes?)` | Wraps nodes with try/catch error recovery <br>⚠️ **Do NOT** use on nodes that call `interrupt()` — `GraphInterrupt` will be rejected |
+| `.withNodes(...names)` | Type-level helper to inform TypeScript of dynamically-added node names |
+| `.compileAsync(...)` | Async version of `compile()` — supports async inject modules |
+
+- All methods support method chaining
+- Compatible with checkpointing, interrupt, streaming, and retryPolicy
+
+## 📦 Installation
+
+```bash
+npm install langgraph-middleware @langchain/langgraph @langchain/core
+```
+
+## Use Cases
+
+This library is ideal for:
+
+- Quickly adding logging, validation, or state transformation before/after specific nodes
+- Reusing the same graph structure across multiple projects (`.inject()`)
+- Attaching tracing / callback handlers to specific nodes (`.observe()`)
+- Rapidly adding/removing nodes and edges without verbose `addNode`/`addEdge` chains (`.inject()`, `.middleware()`)
+- Wrapping a node in a try/catch block for graceful error recovery (`.catch()`)
+- You accept that before/after hooks are implemented as a small internal subgraph (`.middleware()`)
+
+### Not Recommended
+
+- Heavy reliance on `.catch()` for error handling — prefer explicit error-handling nodes for complex logic
+
+## 🚀 Quick Start
+
+### Middleware
+
+`.middleware()` internally turns your node into a small subgraph (`before_{name}` → `{name}` → `after_{name}`).
+
+```ts
+import { StateGraph, Annotation, START, END } from "@langchain/langgraph";
+
+const GraphState = Annotation.Root({
+  input: Annotation<string>(),
+  logs: Annotation<string[]>({
+    reducer: (curr, next) => [...(curr ?? []), ...(next ?? [])],
+    default: () => [],
+  }),
+});
+
+const graph = new StateGraph(GraphState)
+  .addNode("process", async (state) => {
+    return { result: `done: ${state.input}` };
+  })
+  .addEdge(START, "process")
+  .addEdge("process", END)
+  .middleware(
+    "process",
+    // before hook
+    (state) => {
+      console.log("before:", state.input);
+      return { logs: ["starting"] };
+    },
+    // after hook
+    (state) => {
+      console.log("after:", state.result);
+      return { logs: ["finished"] };
+    }
+  )
+  .compile();
+
+const result = await graph.invoke({ input: "hello" });
+console.log(result);
+```
+
+### Inject Modules
+
+Create reusable modules that modify any graph before compilation:
+
+```ts
+import { StateGraph, Annotation, START, END, type StateGraphWithInject } from "@langchain/langgraph";
+
+const MyAnnotation = Annotation.Root({ value: Annotation<string>() });
+
+// The second generic parameter tells TypeScript which node names the module adds
+const addLoggingModule = (
+  graph: StateGraphWithInject<StateGraph<typeof MyAnnotation>, "logger" | "prepare_logger">
+) => {
+  return graph
+    .addNode("prepare_logger", (state) => state)
+    .addNode("logger", async (state) => {
+      console.log("State:", state);
+      return {};
+    })
+    .addEdge(START, "prepare_logger")
+    .addEdge("prepare_logger", "logger");
+};
+
+const graph = new StateGraph(MyAnnotation)
+  .addNode("main", mainNode)
+  .addEdge("logger", "main")
+  .addEdge("main", END)
+  .inject(addLoggingModule)
+  .inject(state => state)                    // Inline usage
+  .inject(moduleA, moduleB, moduleC)         // Multiple modules at once
+  .compile(); // Use compileAsync() if you injected async modules
+```
+
+> **Important timing note:** `.middleware()`, `.catch()`, and `.observe()` scan nodes at **builder-chain time**. Nodes added via `.inject()` are registered at **compile time** (later). To apply middleware/catch/observe to inject-added nodes, call those methods *inside* the inject module itself. See `examples/inject.ts` for patterns.
+
+### Error Handling
+
+```ts
+const graph = new StateGraph(MyAnnotation)
+  .addNode("risky", riskyNode)
+  .addEdge(START, "risky")
+  .addEdge("risky", END)
+  .catch(
+    (error, state, meta) => {
+      console.error(`Node failed:`, error);
+      return { fallback: true, error: String(error) };
+    },
+    "risky", // Omit to wrap all existing nodes, or list specific ones: "node1", "node2", ...
+  )
+  .compile();
+```
+
+### Observability
+
+```ts
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+
+class MyTimer extends BaseCallbackHandler {
+  name = "MyTimer";
+  async handleChainStart(_chain, _inputs, runId, _parentRunId, _tags, _metadata, _runType, name) {
+    console.log(`⏱️  [${name}] started`);
+  }
+  async handleChainEnd(_outputs, runId) {
+    console.log(`✅ [${runId.slice(0, 8)}] completed`);
+  }
+}
+
+const graph = new StateGraph(MyAnnotation)
+  .addNode("step1", step1)
+  .addNode("step2", step2)
+  .addEdge(START, "step1")
+  .addEdge("step1", "step2")
+  .addEdge("step2", END)
+  .observe([new MyTimer()]) // Omitting node names applies to all nodes
+  .compile();
+```
+
+## API Reference
+
+### `.middleware(name, before?, after?, options?)`
+
+Attaches before/after hooks around a node. Internally creates a subgraph.
+
+**Restrictions:**
+- Called **at most once** per node name (repeated calls throw)
+- `before` function **must not** return a `Command` (throws at runtime)
+
+```ts
+.middleware(
+  "myNode",
+  (state) => { /* before */ return { logs: ["start"] }; },
+  (state) => { /* after  */ return { logs: ["end"] }; }
+)
+```
+
+The `after` hook supports `{ func, options }` form for retryPolicy or other node options. The `before` hook also supports this form. An optional 4th argument forwards compile options to the internal subgraph.
+
+### `.inject(...modules)`
+
+Registers reusable modules executed in order just before `compile()`. Modules receive the `StateGraph` instance and should return it for chaining.
+
+```ts
+.inject((graph) => {
+  return graph
+    .addNode("logger", (s) => { console.log(s); return {}; })
+    .addEdge(START, "logger");
+})
+```
+
+Supports both sync and async modules. Use `.compileAsync()` when async modules are present — using `.compile()` with async modules throws.
+
+### `.catch(handler, ...names?)`
+
+Wraps targeted nodes in try/catch. The handler receives `(error, state, meta)` where `meta` is the `RunnableConfig` (includes `metadata`, `executionInfo`, etc.).
+
+- Handler returns a value → the node is treated as successful (short-circuits any remaining retries)
+- Handler throws → the error propagates to LangGraph's normal retryPolicy logic
+
+**⚠️ Do NOT use on nodes that call `interrupt()`.** If a `GraphInterrupt` is caught, it is immediately re-thrown as a regular Error to prevent checkpoint corruption.
+
+If no node names are provided, all *currently registered* nodes are wrapped.
+
+### `.observe(callbacks, ...names?)`
+
+Attaches LangChain `BaseCallbackHandler` instances to nodes. The `runName` in callback events is set to the node name for easy identification in traces.
+
+If no node names are provided, all *currently registered* nodes are observed.
+
+### `.withNodes(...names)`
+
+A type-level-only helper. Does nothing at runtime — it tells TypeScript that certain node names exist on the builder, enabling type inference after conditional `addNode` calls or `.inject()` usage.
+
+```ts
+const builder = new StateGraph(GraphState)
+  .addNode("node1", fn);
+
+if (someCondition) {
+  builder.addNode("node2", fn).addNode("node3", fn);
+}
+
+builder
+  .withNodes("node2", "node3")  // TypeScript now knows about these
+  .addEdge("__start__", "node1")
+  .addEdge("node1", "node2")
+  .addEdge("node2", "node3");
+```
+
+### `.compileAsync(...args)`
+
+Async version of `compile()`. Awaits all registered inject modules (including async ones) before compilation.
+
+```ts
+const graph = await builder.compileAsync(checkpointerOptions);
+```
+
+## Examples
+
+See the `examples/` directory for runnable demos:
+
+| File | Description |
+|------|-------------|
+| `middleware.ts` | Before/after hooks with traceable wrappers and retryPolicy |
+| `middleware-with-checkpointer.ts` | Middleware + checkpoint persistence, xray inspection |
+| `inject.ts` | Async inject modules, conditional edges, error handler injection |
+| `catch.ts` | Error recovery with catch(), multiple target nodes |
+| `catch-with-retry.ts` | catch() + retryPolicy: conditional re-throw pattern |
+| `catch-interrupt-limitation.ts` | Documents the catch + interrupt() incompatibility |
+| `observe.ts` | Callback-based timing/monitoring |
+| `withNodes.ts` | Type-level helper for dynamically-added nodes |
+
+Run any example with:
+```bash
+npx tsx examples/<name>.ts
+```
+
+## Run Tests
+
+All features are verified with comprehensive tests:
+
+```bash
+npm test
+```
+
+## License
+
+MIT © jakehkw
+
+## Links
+
+- GitHub: https://github.com/jakehkw/langgraph-middleware
+- npm: https://www.npmjs.com/package/langgraph-middleware

package/dist/catch.d.ts

@@ -0,0 +1,22 @@
+import { type StateGraph } from '@langchain/langgraph';
+import type { StateOf } from './types.js';
+/**
+ * Wraps one or more nodes with try/catch error handling.
+ *
+ * When a wrapped node throws, the error handler is invoked with:
+ *   - `error` — the thrown value
+ *   - `state` — the state at the time of failure
+ *   - `meta` — the metadata for the node
+ *
+ * The handler's return value is used as the node's output, allowing graceful
+ * recovery or state mutation on failure.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this  - The `StateGraph` instance
+ * @param handler - Error handler receiving (error, state, meta)
+ * @param names   - Optional list of node names to wrap; if omitted, all nodes
+ * @returns `this` for chaining
+ * @internal
+ */
+export declare function catchError<T extends StateGraph<any>>(this: T, handler: (error: unknown, state: Partial<StateOf<T>>, meta: any) => Partial<StateOf<T>> | Promise<Partial<StateOf<T>>>, ...names: string[]): T;
+//# sourceMappingURL=catch.d.ts.map

package/dist/catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../src/catch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,KAAK,EAAE,OAAO,EAAe,MAAM,YAAY,CAAC;AAGvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,UAAU,CAAC,GAAG,CAAC,EAClD,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,CACP,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE,GAAG,KACN,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EACvD,GAAG,KAAK,EAAE,MAAM,EAAE,KAkDnB"}

package/dist/catch.js

@@ -0,0 +1,67 @@
+import { GraphInterrupt } from '@langchain/langgraph';
+import { RunnableLambda } from '@langchain/core/runnables';
+import { getNodes } from './utils.js';
+/**
+ * Wraps one or more nodes with try/catch error handling.
+ *
+ * When a wrapped node throws, the error handler is invoked with:
+ *   - `error` — the thrown value
+ *   - `state` — the state at the time of failure
+ *   - `meta` — the metadata for the node
+ *
+ * The handler's return value is used as the node's output, allowing graceful
+ * recovery or state mutation on failure.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this  - The `StateGraph` instance
+ * @param handler - Error handler receiving (error, state, meta)
+ * @param names   - Optional list of node names to wrap; if omitted, all nodes
+ * @returns `this` for chaining
+ * @internal
+ */
+export function catchError(handler, ...names) {
+    const nodes = this.nodes;
+    const targets = getNodes(names, nodes);
+    for (const [nodeName, spec] of Object.entries(targets)) {
+        // Design:
+        // We always run the original runnable first.
+        // If it throws, we immediately give the error to the user's handler.
+        //
+        // - If handler returns a value → this attempt is treated as success.
+        //   LangGraph will NOT retry further for this task (even if retries remained).
+        // - If handler throws → the error propagates to LangGraph, which will then
+        //   apply its normal retryPolicy logic for the next attempt (if any remain).
+        //
+        // Trade-off:
+        // This means that for nodes with retryPolicy, using .catch will cause the
+        // handler to be invoked on the FIRST error (not only the last).
+        // Returning a value from the handler will short-circuit any remaining retries.
+        //
+        // This is the cleanest and most predictable behavior we can achieve at the
+        // current wrapper level while still giving the user powerful control.
+        const wrappedRunnable = RunnableLambda.from(async (state, config) => {
+            try {
+                return await spec.runnable.invoke(state, config);
+            }
+            catch (err) {
+                if (err instanceof GraphInterrupt) {
+                    throw new Error(`[.catch] Caught a GraphInterrupt in node "${nodeName}". 
+              This likely means you are using .catch() on a node that calls interrupt(), which is not supported. 
+              The interrupt will be treated as a normal error and passed to your handler, 
+              which can lead to unexpected behavior. 
+              Please remove .catch() from this node or ensure it does not call interrupt().`);
+                }
+                const result = await Promise.resolve(handler(err, state, config));
+                // If the handler itself throws, it will propagate out of this RunnableLambda.
+                // LangGraph will then treat it according to its normal error/retry rules.
+                return result;
+            }
+        });
+        nodes[nodeName] = {
+            ...spec,
+            runnable: wrappedRunnable,
+        };
+    }
+    return this;
+}
+//# sourceMappingURL=catch.js.map

package/dist/catch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.js","sourceRoot":"","sources":["../src/catch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmB,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CAExB,OAIuD,EACvD,GAAG,KAAe;IAElB,MAAM,KAAK,GAAI,IAAY,CAAC,KAAoC,CAAC;IACjE,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEvC,KAAK,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACvD,UAAU;QACV,6CAA6C;QAC7C,qEAAqE;QACrE,EAAE;QACF,qEAAqE;QACrE,+EAA+E;QAC/E,2EAA2E;QAC3E,6EAA6E;QAC7E,EAAE;QACF,aAAa;QACb,0EAA0E;QAC1E,gEAAgE;QAChE,+EAA+E;QAC/E,EAAE;QACF,2EAA2E;QAC3E,sEAAsE;QACtE,MAAM,eAAe,GAAG,cAAc,CAAC,IAAI,CACzC,KAAK,EAAE,KAAiB,EAAE,MAAY,EAAE,EAAE;YACxC,IAAI,CAAC;gBACH,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACnD,CAAC;YAAC,OAAO,GAAY,EAAE,CAAC;gBACtB,IAAI,GAAG,YAAY,cAAc,EAAE,CAAC;oBAClC,MAAM,IAAI,KAAK,CAAC,6CAA6C,QAAQ;;;;4FAIW,CAAC,CAAC;gBACpF,CAAC;gBAED,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;gBAClE,8EAA8E;gBAC9E,0EAA0E;gBAC1E,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC,CACF,CAAC;QAEF,KAAK,CAAC,QAAQ,CAAC,GAAG;YAChB,GAAG,IAAI;YACP,QAAQ,EAAE,eAAe;SAC1B,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/compile.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":""}

package/dist/compile.js

@@ -0,0 +1,45 @@
+import { StateGraph } from '@langchain/langgraph';
+import { getInjectModules } from './inject.js';
+/** Reference to the original `StateGraph.prototype.compile` method. */
+const originalCompile = StateGraph.prototype.compile;
+/**
+ * Overrides `StateGraph.prototype.compile` to execute all registered inject
+ * modules before the original compilation logic runs.
+ *
+ * **Important:** Async inject modules are NOT supported here — use
+ * `.compileAsync()` for modules that return a `Promise`.
+ *
+ * @param args - Arguments forwarded to the original `compile()` method
+ * @returns A compiled state graph
+ * @internal
+ */
+StateGraph.prototype.compile = function (...args) {
+    const self = this;
+    const modules = getInjectModules(self);
+    for (const mod of modules) {
+        const result = mod(self);
+        if (result instanceof Promise) {
+            throw new Error('Async module detected in StateGraph.inject(). ' +
+                'Module must be synchronous when using .compile() — ' +
+                'if you need async setup, use .compileAsync() instead.');
+        }
+    }
+    return originalCompile.apply(self, args);
+};
+/**
+ * Implementation of `StateGraph.prototype.compileAsync`
+ * Execute all registered inject modules (including async ones) before compilation.
+ *
+ * @param args - Arguments forwarded to the original `compile()` method
+ * @returns A Promise resolving to a compiled state graph
+ * @internal
+ */
+StateGraph.prototype.compileAsync = async function (...args) {
+    const self = this;
+    const modules = getInjectModules(self);
+    for (const mod of modules) {
+        await Promise.resolve(mod(self));
+    }
+    return originalCompile.apply(self, args);
+};
+//# sourceMappingURL=compile.js.map

package/dist/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,uEAAuE;AACvE,MAAM,eAAe,GAAG,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC;AAErD;;;;;;;;;;GAUG;AACF,UAAU,CAAC,SAAiB,CAAC,OAAO,GAAG,UAAU,GAAG,IAAe;IAClE,MAAM,IAAI,GAAG,IAAW,CAAC;IACzB,MAAM,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAEvC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACzB,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,gDAAgD;gBAC9C,qDAAqD;gBACrD,uDAAuD,CAC1D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,EAAE,IAAW,CAAC,CAAC;AAClD,CAAC,CAAC;AAEF;;;;;;;GAOG;AACF,UAAU,CAAC,SAAiB,CAAC,YAAY,GAAG,KAAK,WAAW,GAAG,IAAe;IAC7E,MAAM,IAAI,GAAG,IAAW,CAAC;IACzB,MAAM,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAEvC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,eAAe,CAAC,KAAK,CAAC,IAAW,EAAE,IAAW,CAAsC,CAAC;AAC9F,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+/**
+ * langgraph-middleware
+ * ===================
+ * Middleware utilities for LangGraph's `StateGraph`.
+ *
+ * @packageDocumentation
+ */
+import type { START, CompiledStateGraph, StateDefinitionInit, ExtractStateType, ExtractUpdateType, StateDefinition, ToStateDefinition, AnyStateSchema } from '@langchain/langgraph';
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { StateOf, NodeNamesOf, ExtractStateGraphModule, LastFunction, StateCallback, MiddleHook } from './types';
+type ExtractStateDefinition<T> = T extends AnyStateSchema ? T : T extends StateDefinitionInit ? ToStateDefinition<T> : StateDefinition;
+declare module '@langchain/langgraph' {
+    type StateGraphWithInject<T, NewNodes extends string | readonly string[] = typeof START> = T extends StateGraph<infer A, infer B, infer C, infer Node, infer D, infer E, infer F, infer G, infer H, infer I> ? StateGraph<A, B, C, Node | (NewNodes extends readonly string[] ? NewNodes[number] : NewNodes), D, E, F, G, H, I> : never;
+    interface StateGraph<SD extends StateDefinitionInit | unknown, S = ExtractStateType<SD>, U = ExtractUpdateType<SD, S>, N extends string = typeof START, I extends StateDefinitionInit = ExtractStateDefinition<SD>, O extends StateDefinitionInit = ExtractStateDefinition<SD>, C extends StateDefinitionInit = StateDefinition, NodeReturnType = unknown, InterruptType = unknown, WriterType = unknown> {
+        /**
+         * Implementation of `StateGraph.prototype.inject`.
+         *
+         * Registers one or more functions that will be executed in order before the graph is compiled.
+         * Supports method chaining.
+         * @param modules - One or more inject modules containing the graph instance in its param.
+         * @returns `this` for chaining
+         */
+        inject<T extends ((p: this) => this)[]>(...modules: T): this;
+        inject<T extends any[], U extends ExtractStateGraphModule<LastFunction<T[number]>>, const Nodes extends NodeNamesOf<Parameters<U>[0]>>(...modules: T): StateGraphWithInject<StateGraph<SD, S, ExtractUpdateType<SD, S>, NodeNamesOf<this> | N, ExtractStateDefinition<SD>, ExtractStateDefinition<SD>, StateDefinition, unknown, unknown, unknown>, Nodes>;
+        /**
+         * Wraps one or more nodes with try/catch error handling.
+         *
+         * When a wrapped node throws, the error handler is invoked with:
+         *   - `error` — the thrown value
+         *   - `state` — the state at the time of failure
+         *   - `meta`  — the RunnableConfig (with metadata, executionInfo, etc.)
+         *
+         * The handler's return value is used as the node's output, allowing graceful
+         * recovery or state mutation on failure.
+         *
+         * ⚠️ IMPORTANT RESTRICTION:
+         * You **cannot** use `.catch()` on nodes that may call `interrupt()`.
+         * If `GraphInterrupt` is caught, it is immediately re-thrown as a regular
+         * Error to prevent silent checkpoint corruption. The handler will NOT receive it.
+         *
+         * @param handler - Error handler receiving (error, state, meta)
+         * @param names   - Optional list of node names to wrap; if omitted, all existing nodes
+         * @returns `this` for chaining
+         */
+        catch(handler: (error: any, state: Partial<StateOf<this>>, meta: any) => Partial<StateOf<this>> | Promise<Partial<StateOf<this>>>, ...names: NodeNamesOf<this>[]): this;
+        /**
+         * Attaches LangChain callback handlers to one or more nodes for
+         * observability (logging, tracing, monitoring).
+         *
+         * Each targeted node is wrapped so that its execution is reported through
+         * the provided callbacks. The `runName` in callback events is set to the
+         * node name for easy identification.
+         *
+         * @param callbacks - Array of callback handlers to attach
+         * @param names - Optional list of node names to observe; if omitted, all nodes
+         * @returns `this` for chaining
+         */
+        observe(callbacks: BaseCallbackHandler[], ...names: NodeNamesOf<this>[]): this;
+        /**
+         * Attach before/after hooks around a node.
+         *
+         * Restrictions (enforced):
+         * - You may call .middleware() **at most once** per node name on a given builder.
+         *   Nested / repeated calls on the same node are rejected (prevents non-linear execution and
+         *   exponential before-hook duplication that occurs with deep nesting).
+         * - The `before` function **must not** return a `Command`. Doing so will throw at runtime.
+         *   Use the main node or the `after` hook for any Command-based routing.
+         *
+         * @param name  - Name of a previously registered node
+         * @param before - Optional before hook (plain function or { func, options })
+         * @param after  - Optional after hook (plain function or { func, options })
+         * @param options  - Compile options for the internal subgraph (advanced)
+         * @returns `this` for chaining
+         */
+        middleware<T = MiddleHook<StateCallback<StateOf<this>>, StateOf<this>>, U = T, V = T>(name: NodeNamesOf<this>, before?: U, after?: V, options?: Parameters<this['compile']>[0]): this;
+        /**
+         * Implementation of `StateGraph.prototype.compileAsync`
+         * Execute all registered inject modules (including async ones) before compilation.
+         *
+         * @param args - Arguments forwarded to the original `compile()` method
+         * @returns A Promise resolving to a compiled state graph
+         */
+        compileAsync(...args: any[]): Promise<CompiledStateGraph<any, any, any>>;
+        /**
+         * A type-level only chain method to explicitly tell TypeScript
+         * that certain node names now exist on this builder.
+         *
+         * This is useful after .inject() or stepwise .addNode() calls,
+         * where the variable's static type hasn't automatically picked up
+         * the newly added nodes.
+         *
+         * Example:
+         *   const b = new StateGraph(GraphState)
+         *     .inject(addTimestampModule)
+         *     .withNodes<'timestamp'>();
+         *
+         * After this, NodeNamesOf<typeof b> will include "timestamp".
+         */
+        withNodes<Nodes extends string[]>(...names: Nodes): StateGraphWithInject<StateGraph<SD, S, ExtractUpdateType<SD, S>, NodeNamesOf<this>, ExtractStateDefinition<SD>, ExtractStateDefinition<SD>, StateDefinition, unknown, unknown, unknown>, Nodes>;
+    }
+}
+import './compile.js';
+export type { StateOf, NodeNamesOf } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * langgraph-middleware
+ * ===================
+ * Middleware utilities for LangGraph's `StateGraph`.
+ *
+ * @packageDocumentation
+ */
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+// ═══════════════════════════════════════════════════════════════════════
+// Apply prototype augmentations (side effects)
+// ═══════════════════════════════════════════════════════════════════════
+import { StateGraph } from '@langchain/langgraph';
+import './compile.js';
+import { inject } from './inject.js';
+import { middleware } from './middleware.js';
+import { catchError } from './catch.js';
+import { observe } from './observe.js';
+import { withNodes } from './withNodes';
+const proto = StateGraph.prototype;
+if (!Object.prototype.hasOwnProperty.call(proto, 'inject')) {
+    proto.inject = inject;
+}
+if (!Object.prototype.hasOwnProperty.call(proto, 'middleware')) {
+    proto.middleware = middleware;
+}
+if (!Object.prototype.hasOwnProperty.call(proto, 'catch')) {
+    proto.catch = catchError;
+}
+if (!Object.prototype.hasOwnProperty.call(proto, 'observe')) {
+    proto.observe = observe;
+}
+if (!Object.prototype.hasOwnProperty.call(proto, 'withNodes')) {
+    proto.withNodes = withNodes;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAiJrE,0EAA0E;AAC1E,+CAA+C;AAC/C,0EAA0E;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,cAAc,CAAC;AACtB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,KAAK,GAAG,UAAU,CAAC,SAAgB,CAAC;AAE1C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC;IAC3D,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;AACxB,CAAC;AACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,EAAE,CAAC;IAC/D,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;AAChC,CAAC;AACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1D,KAAK,CAAC,KAAK,GAAG,UAAU,CAAC;AAC3B,CAAC;AACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IAC5D,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;AAC1B,CAAC;AACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,CAAC;IAC9D,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;AAC9B,CAAC"}

package/dist/inject.d.ts

@@ -0,0 +1,22 @@
+import type { StateGraph } from '@langchain/langgraph';
+type Graph = StateGraph<any>;
+/**
+ * Retrieves (or creates) the inject-module queue for a given `StateGraph`
+ * instance.
+ * @internal
+ */
+export declare function getInjectModules(graph: Graph): ((...p: any) => any)[];
+/**
+ * Implementation of `StateGraph.prototype.inject`.
+ *
+ * Registers one or more functions that will be executed in order before the graph is compiled.
+ * Supports method chaining.
+ *
+ * @param this  - The `StateGraph` instance
+ * @param modules - One or more inject modules
+ * @returns `this` for chaining
+ * @internal
+ */
+export declare function inject(this: Graph, ...modules: ((...p: any) => any)[]): Graph;
+export {};
+//# sourceMappingURL=inject.d.ts.map

package/dist/inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../src/inject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,KAAK,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;AAU5B;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,GACX,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC,EAAE,CAOxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,KAAK,EACX,GAAG,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC,EAAE,SAKnC"}

package/dist/inject.js

@@ -0,0 +1,34 @@
+// ── Per-graph inject module queue ─────────────────────────────────────
+// We use a WeakMap keyed on each StateGraph instance so that modules are
+// garbage-collected when the graph is no longer referenced.
+const modulesMap = new WeakMap();
+/**
+ * Retrieves (or creates) the inject-module queue for a given `StateGraph`
+ * instance.
+ * @internal
+ */
+export function getInjectModules(graph) {
+    let list = modulesMap.get(graph);
+    if (!list) {
+        list = [];
+        modulesMap.set(graph, list);
+    }
+    return list;
+}
+/**
+ * Implementation of `StateGraph.prototype.inject`.
+ *
+ * Registers one or more functions that will be executed in order before the graph is compiled.
+ * Supports method chaining.
+ *
+ * @param this  - The `StateGraph` instance
+ * @param modules - One or more inject modules
+ * @returns `this` for chaining
+ * @internal
+ */
+export function inject(...modules) {
+    const list = getInjectModules(this);
+    list.push(...modules);
+    return this;
+}
+//# sourceMappingURL=inject.js.map

package/dist/inject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.js","sourceRoot":"","sources":["../src/inject.ts"],"names":[],"mappings":"AAIA,yEAAyE;AACzE,yEAAyE;AACzE,4DAA4D;AAC5D,MAAM,UAAU,GAAG,IAAI,OAAO,EAG3B,CAAC;AAEJ;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAY;IAEZ,IAAI,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,IAAI,GAAG,EAAE,CAAC;QACV,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,MAAM,CAEpB,GAAG,OAA+B;IAElC,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;IACtB,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/middleware.d.ts

@@ -0,0 +1,23 @@
+import { StateGraph } from '@langchain/langgraph';
+import type { MiddleHook, StateCallback, StateOf } from './types';
+/**
+ * Attach before/after hooks around a node.
+ *
+ * Restrictions (enforced):
+ * - You may call .middleware() **at most once** per node name on a given builder.
+ *   Nested / repeated calls on the same node are rejected (prevents non-linear execution and
+ *   exponential before-hook duplication that occurs with deep nesting).
+ * - The `before` function **must not** return a `Command`. Doing so will throw at runtime.
+ *   Use the main node or the `after` hook for any Command-based routing.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this  - The `StateGraph` instance
+ * @param name  - Name of a previously registered node
+ * @param before - Hook executed before the original node (optional)
+ * @param after  - Hook executed after the original node (optional)
+ * @param options  - Compile options for the internal subgraph (advanced)
+ * @returns `this` for chaining
+ * @internal
+ */
+export declare function middleware<T extends StateGraph<any>>(this: T, name: string, before?: MiddleHook<StateCallback<StateOf<T>>, StateOf<T>>, after?: MiddleHook<StateCallback<StateOf<T>>, StateOf<T>>, options?: Parameters<T['compile']>[0]): T;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,UAAU,EAA4B,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAalE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,UAAU,CAAC,GAAG,CAAC,EAClD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EAC1D,KAAK,CAAC,EAAE,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EACzD,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,KAmEtC"}

package/dist/middleware.js

@@ -0,0 +1,81 @@
+import { END, START, StateGraph, isCommand } from '@langchain/langgraph';
+const MIDDLEWARE_WRAPPED = Symbol('middlewareWrapped');
+const extract = (par) => {
+    if (typeof par === 'function') {
+        return { func: par, options: {} };
+    }
+    return { func: par.func, options: par.options ?? {} };
+};
+/**
+ * Attach before/after hooks around a node.
+ *
+ * Restrictions (enforced):
+ * - You may call .middleware() **at most once** per node name on a given builder.
+ *   Nested / repeated calls on the same node are rejected (prevents non-linear execution and
+ *   exponential before-hook duplication that occurs with deep nesting).
+ * - The `before` function **must not** return a `Command`. Doing so will throw at runtime.
+ *   Use the main node or the `after` hook for any Command-based routing.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this  - The `StateGraph` instance
+ * @param name  - Name of a previously registered node
+ * @param before - Hook executed before the original node (optional)
+ * @param after  - Hook executed after the original node (optional)
+ * @param options  - Compile options for the internal subgraph (advanced)
+ * @returns `this` for chaining
+ * @internal
+ */
+export function middleware(name, before, after, options) {
+    const nodes = this.nodes;
+    const nodeSpec = nodes[name];
+    if (!nodeSpec) {
+        throw new Error(`Node "${name}" does not exist on this graph. ` +
+            `Register it first with .addNode("${name}", ...)`);
+    }
+    // Block nested middleware on the same node (prevents exponential before-hook duplication)
+    if (nodeSpec[MIDDLEWARE_WRAPPED]) {
+        throw new Error(`Cannot apply .middleware() to node "${name}" — it has already been wrapped by a previous .middleware() call.\n` +
+            'Nested middleware on the same node is not supported.\n' +
+            'If you need multiple before/after stages, compose the logic inside a single .middleware() call or use explicit nodes + edges instead.');
+    }
+    const subGraph = new StateGraph(this.channels).addNode(name, nodeSpec.runnable);
+    if (before) {
+        const { func, options: nodeOptions } = extract(before);
+        // Guard: Before hooks must never return Command (leads to surprising non-native behavior)
+        const guardedBefore = async (state, config) => {
+            const result = await Promise.resolve(func(state, config));
+            if (isCommand(result)) {
+                throw new Error(`Before hooks passed to .middleware("${name}", beforeFn, ...) are not allowed to return Command objects.\n` +
+                    'Returning Command from a before hook does not behave reliably (the original node may still execute).\n' +
+                    'Please perform routing with Command from the main node function or the after hook instead.');
+            }
+            return result;
+        };
+        subGraph
+            .addNode('before_' + name, guardedBefore, nodeOptions)
+            .addEdge(START, 'before_' + name)
+            .addEdge('before_' + name, name);
+    }
+    else {
+        subGraph.addEdge(START, name);
+    }
+    if (after) {
+        const { func, options: nodeOptions } = extract(after);
+        subGraph
+            .addNode('after_' + name, func, nodeOptions)
+            .addEdge(name, 'after_' + name)
+            .addEdge('after_' + name, END);
+    }
+    else {
+        subGraph.addEdge(name, END);
+    }
+    delete nodes[name];
+    this.addNode(name, subGraph.compile(options));
+    // Mark the newly wrapped node so future .middleware() calls on it are rejected
+    const newSpec = nodes[name];
+    if (newSpec) {
+        newSpec[MIDDLEWARE_WRAPPED] = true;
+    }
+    return this;
+}
+//# sourceMappingURL=middleware.js.map

package/dist/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAiB,MAAM,sBAAsB,CAAC;AAKxF,MAAM,kBAAkB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAEvD,MAAM,OAAO,GAAG,CAA4B,GAAsD,EAAE,EAAE;IACpG,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACpC,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;AACxD,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,UAAU,CAExB,IAAY,EACZ,MAA0D,EAC1D,KAAyD,EACzD,OAAqC;IAErC,MAAM,KAAK,GAAI,IAAY,CAAC,KAAoC,CAAC;IACjE,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAE7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CACb,SAAS,IAAI,kCAAkC;YAC7C,oCAAoC,IAAI,SAAS,CACpD,CAAC;IACJ,CAAC;IAED,0FAA0F;IAC1F,IAAI,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,uCAAuC,IAAI,qEAAqE;YAChH,wDAAwD;YACxD,uIAAuI,CACxI,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAEhF,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QAEvD,0FAA0F;QAC1F,MAAM,aAAa,GAAG,KAAK,EAAE,KAAU,EAAE,MAAY,EAAE,EAAE;YACvD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;YAC1D,IAAI,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CACb,uCAAuC,IAAI,gEAAgE;oBAC3G,wGAAwG;oBACxG,4FAA4F,CAC7F,CAAC;YACJ,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;QAEF,QAAQ;aACL,OAAO,CAAC,SAAS,GAAG,IAAI,EAAE,aAAa,EAAE,WAAW,CAAC;aACrD,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;aAChC,OAAO,CAAC,SAAS,GAAG,IAAI,EAAE,IAAI,CAAC,CAAC;IACrC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QACtD,QAAQ;aACL,OAAO,CAAC,QAAQ,GAAG,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC;aAC3C,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;aAC9B,OAAO,CAAC,QAAQ,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;IACnC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;IACnB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAE9C,+EAA+E;IAC/E,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACrC,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/observe.d.ts

@@ -0,0 +1,19 @@
+import type { StateGraph } from '@langchain/langgraph';
+import type { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+/**
+ * Attaches LangChain callback handlers to one or more nodes for
+ * observability (logging, tracing, monitoring).
+ *
+ * Each targeted node is wrapped so that its execution is reported through
+ * the provided callbacks. The `runName` in callback events is set to the
+ * node name for easy identification.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this      - The `StateGraph` instance
+ * @param callbacks - Array of callback handlers to attach
+ * @param names     - Optional list of node names to observe; if omitted, all nodes
+ * @returns `this` for chaining
+ * @internal
+ */
+export declare function observe<T extends StateGraph<any>>(this: T, callbacks: BaseCallbackHandler[], ...names: string[]): T;
+//# sourceMappingURL=observe.d.ts.map

package/dist/observe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,sBAAsB,CAAC;AAGjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAM1E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,UAAU,CAAC,GAAG,CAAC,EAC/C,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,mBAAmB,EAAE,EAChC,GAAG,KAAK,EAAE,MAAM,EAAE,KAqBnB"}

package/dist/observe.js

@@ -0,0 +1,33 @@
+import { RunnableLambda } from '@langchain/core/runnables';
+import { getNodes } from './utils.js';
+/**
+ * Attaches LangChain callback handlers to one or more nodes for
+ * observability (logging, tracing, monitoring).
+ *
+ * Each targeted node is wrapped so that its execution is reported through
+ * the provided callbacks. The `runName` in callback events is set to the
+ * node name for easy identification.
+ *
+ * @typeParam T - The `StateGraph` subtype
+ * @param this      - The `StateGraph` instance
+ * @param callbacks - Array of callback handlers to attach
+ * @param names     - Optional list of node names to observe; if omitted, all nodes
+ * @returns `this` for chaining
+ * @internal
+ */
+export function observe(callbacks, ...names) {
+    const nodes = this.nodes;
+    const targets = getNodes(names, nodes);
+    for (const [nodeName, spec] of Object.entries(targets)) {
+        const wrappedRunnable = RunnableLambda.from(async (state, config) => spec.runnable.invoke(state, config)).withConfig({
+            callbacks,
+            runName: nodeName,
+        });
+        nodes[nodeName] = {
+            ...spec,
+            runnable: wrappedRunnable,
+        };
+    }
+    return this;
+}
+//# sourceMappingURL=observe.js.map

package/dist/observe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.js","sourceRoot":"","sources":["../src/observe.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAI3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,OAAO,CAErB,SAAgC,EAChC,GAAG,KAAe;IAElB,MAAM,KAAK,GAAI,IAAY,CAAC,KAAoC,CAAC;IACjE,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEvC,KAAK,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACvD,MAAM,eAAe,GAAG,cAAc,CAAC,IAAI,CACzC,KAAK,EAAE,KAAiB,EAAE,MAAuB,EAAE,EAAE,CACnD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CACtC,CAAC,UAAU,CAAC;YACX,SAAS;YACT,OAAO,EAAE,QAAQ;SAClB,CAAC,CAAC;QAEH,KAAK,CAAC,QAAQ,CAAC,GAAG;YAChB,GAAG,IAAI;YACP,QAAQ,EAAE,eAAe;SAC1B,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+import type { END, NodeSpec, START, StateGraph, StateGraphAddNodeOptions } from '@langchain/langgraph';
+import type { TraceableFunction } from 'langsmith/traceable';
+/**
+ * Extract all states from StateGraph
+ */
+export type StateOf<T> = T extends StateGraph<any, infer S, any, any, any, any, any, any, any, any> ? S : never;
+/**
+ * Extract all node names from StateGraph (exclude START / END)
+ */
+export type NodeNamesOf<T> = T extends StateGraph<any, any, any, infer N, any, any, any, any, any, any> ? Exclude<N, typeof START | typeof END> : never;
+/**
+ * Unwrap traceable-wrapped functions to their inner type.
+ * Extensible for other wrapper types as needed.
+ */
+type ExtractFrom<T> = T extends TraceableFunction<infer A> ? A : T;
+type IsStateGraph<T> = T extends Promise<StateGraph<any, any, any, any>> | StateGraph<any, any, any, any> ? true : false;
+export type ExtractStateGraphModule<T> = T extends IsStateGraph<T> ? (p: T) => T : T extends (...args: any) => infer R ? IsStateGraph<R> extends true ? T : never : never;
+export type StateCallback<T> = (p: T) => Partial<T>;
+export type MiddleHookFunc<T, U> = ExtractFrom<T> extends StateCallback<U> ? T : T extends (...args: any) => infer R ? MiddleHookFunc<R, U> : never;
+export type MiddleHook<T, U> = MiddleHookFunc<T, U> | {
+    func: MiddleHookFunc<T, U>;
+    options?: StateGraphAddNodeOptions;
+};
+export type LastFunction<T> = T extends (...args: any) => infer R ? R extends Promise<infer P> ? P extends (...args: any) => any ? LastFunction<P> : ExtractFrom<T> : R extends AsyncIterable<infer Item> ? LastFunction<Item> : R extends (...args: any) => any ? LastFunction<R> : ExtractFrom<T> : never;
+export type AnyNodeSpec = NodeSpec<any, any> & StateGraphAddNodeOptions;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+import type { AnyNodeSpec } from './types';
+/**
+ * Filters the graph's node registry to only include the specified node names.
+ *
+ * If no names are provided, the entire node registry is returned as-is.
+ * This is used internally by `catch()` and `observe()` to optionally scope
+ * their effects to a subset of nodes.
+ *
+ * @param names - Specific node names to select, or an empty array for all nodes
+ * @param nodes - The full node registry from `StateGraph.nodes`
+ * @returns A filtered copy of the node registry
+ * @internal
+ */
+export declare function getNodes(names: string[], nodes: Record<string, AnyNodeSpec>): Record<string, AnyNodeSpec>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAe7B"}

package/dist/utils.js

@@ -0,0 +1,26 @@
+/**
+ * Filters the graph's node registry to only include the specified node names.
+ *
+ * If no names are provided, the entire node registry is returned as-is.
+ * This is used internally by `catch()` and `observe()` to optionally scope
+ * their effects to a subset of nodes.
+ *
+ * @param names - Specific node names to select, or an empty array for all nodes
+ * @param nodes - The full node registry from `StateGraph.nodes`
+ * @returns A filtered copy of the node registry
+ * @internal
+ */
+export function getNodes(names, nodes) {
+    if (!names || names.length === 0) {
+        return nodes;
+    }
+    const targetNames = new Set(names);
+    const result = {};
+    for (const key of Object.keys(nodes)) {
+        if (targetNames.has(key)) {
+            result[key] = nodes[key];
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAe,EACf,KAAkC;IAElC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;IACnC,MAAM,MAAM,GAAgC,EAAE,CAAC;IAE/C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/withNodes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Runtime implementation for the new type-level helper method.
+ * It does nothing at runtime — its only purpose is to help TypeScript
+ * narrow the 4th generic (N) through the return type.
+ *
+ * @returns `this` for chaining
+ * @internal
+ */
+export declare function withNodes(this: any): any;
+//# sourceMappingURL=withNodes.d.ts.map

package/dist/withNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withNodes.d.ts","sourceRoot":"","sources":["../src/withNodes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,OAElC"}

package/dist/withNodes.js

@@ -0,0 +1,12 @@
+/**
+ * Runtime implementation for the new type-level helper method.
+ * It does nothing at runtime — its only purpose is to help TypeScript
+ * narrow the 4th generic (N) through the return type.
+ *
+ * @returns `this` for chaining
+ * @internal
+ */
+export function withNodes() {
+    return this;
+}
+//# sourceMappingURL=withNodes.js.map

package/dist/withNodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withNodes.js","sourceRoot":"","sources":["../src/withNodes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,IAAI,CAAC;AACd,CAAC"}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "langgraph-middleware",
+  "version": "1.0.0",
+  "description": "Middleware utilities for LangGraph StateGraph — inject modules, before/after hooks, error catching, and callback observation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jakehkw/langgraph-middleware.git"
+  },
+  "keywords": [
+    "langgraph",
+    "langchain",
+    "middleware",
+    "state-graph",
+    "hooks",
+    "inject",
+    "catch",
+    "observe",
+    "before-after",
+    "llm",
+    "ai"
+  ],
+  "author": "jakehkw",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jakehkw/langgraph-middleware/issues"
+  },
+  "homepage": "https://github.com/jakehkw/langgraph-middleware#readme",
+  "peerDependencies": {
+    "langsmith": "^0.7.3",
+    "@langchain/core": "^1.0.0",
+    "@langchain/langgraph": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": {
+      "optional": false
+    },
+    "@langchain/langgraph": {
+      "optional": false
+    },
+    "langsmith": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@langchain/core": "^1.1.47",
+    "@langchain/langgraph": "^1.3.2",
+    "@types/node": "25.9.1",
+    "eslint": "^10.4.0",
+    "globals": "^17.6.0",
+    "langsmith": "^0.7.3",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    "vitest": "4.1.7"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}