don't ship middleware transformer

Author: christian-bromann

libs/langchain-core/src/language_models/chat_models.ts

@@ -353,7 +353,7 @@ export abstract class BaseChatModel<
    *
    * @example
    * ```ts
-   * const stream = model.streamV2([{ role: "user", content: "Hello" }]);
+   * const stream = model.streamEvents([{ role: "user", content: "Hello" }]);
    *
    * // Stream text
    * for await (const token of stream.text) {
@@ -364,7 +364,7 @@ export abstract class BaseChatModel<
    * const message = await stream;
    * ```
    */
-  streamV2(
+  streamEvents(
     input: BaseLanguageModelInput,
     options?: Partial<CallOptions>
   ): ChatModelStream {

libs/langchain/src/agents/ReactAgent.ts

@@ -54,7 +54,6 @@ import {
 } from "./nodes/utils.js";
 import {
   createToolCallTransformer,
-  createMiddlewareTransformer,
   type AgentRunStream,
   type InferStreamExtensions,
 } from "./stream.js";
@@ -674,7 +673,6 @@ export class ReactAgent<
      */
     const compileTransformers = [
       createToolCallTransformer([]),
-      createMiddlewareTransformer([]),
       /* user-defined stream transformers */
       ...(this.options.streamTransformers ?? []),
     ];
@@ -1376,7 +1374,6 @@ export class ReactAgent<
     AgentRunStream<
       MergedAgentState<Types>,
       Types["Tools"],
-      Types["Middleware"],
       InferStreamExtensions<Types["StreamTransformers"]>
     >
   >;
@@ -1446,7 +1443,6 @@ export class ReactAgent<
         AgentRunStream<
           MergedAgentState<Types>,
           Types["Tools"],
-          Types["Middleware"],
           InferStreamExtensions<Types["StreamTransformers"]>
         >
       >
@@ -1508,7 +1504,6 @@ export class ReactAgent<
       })) as unknown as AgentRunStream<
         FullState,
         Types["Tools"],
-        Types["Middleware"],
         InferStreamExtensions<Types["StreamTransformers"]>
       >;
     })();

libs/langchain/src/agents/index.ts

@@ -716,14 +716,5 @@ export { MIDDLEWARE_BRAND } from "./middleware/types.js";
 export type * from "./middleware/types.js";
 export { FakeToolCallingModel } from "./tests/utils.js";
 export type { ReactAgent } from "./ReactAgent.js";
-export {
-  createToolCallTransformer,
-  createMiddlewareTransformer,
-} from "./stream.js";
-export type {
-  AgentRunStream,
-  MiddlewarePhase,
-  MiddlewareEvent,
-  MiddlewareEventUnion,
-  ToolCallStreamUnion,
-} from "./stream.js";
+export { createToolCallTransformer } from "./stream.js";
+export type { AgentRunStream, ToolCallStreamUnion } from "./stream.js";

libs/langchain/src/agents/stream.ts

@@ -22,7 +22,6 @@ import {
   type ToolCallStream,
   type ToolCallStatus,
   type ToolsEventData,
-  type UpdatesEventData,
   type Namespace,
 } from "@langchain/langgraph";
 import type {
@@ -31,10 +30,6 @@ import type {
   DynamicStructuredTool,
   StructuredToolInterface,
 } from "@langchain/core/tools";
-import type {
-  AgentMiddleware,
-  InferMiddlewareState,
-} from "./middleware/types.js";
 
 /**
  * Infers the merged extensions shape from a tuple of stream transformer
@@ -92,46 +87,6 @@ export type ToolCallStreamUnion<
   >;
 }[number];
 
-/**
- * Lifecycle phase that a middleware hook occupies within an agent turn.
- */
-export type MiddlewarePhase =
-  | "before_agent"
-  | "before_model"
-  | "after_model"
-  | "after_agent";
-
-/**
- * Represents a single middleware lifecycle event observed during an
- * agent run. Emitted by the middleware transformer.
- *
- * @typeParam TStateDelta - Shape of the state delta produced by this
- *   middleware. Defaults to `Record<string, unknown>` when the
- *   middleware tuple is not typed.
- */
-export interface MiddlewareEvent<TStateDelta = Record<string, unknown>> {
-  phase: MiddlewarePhase;
-  name: string;
-  stateDelta: TStateDelta;
-  timestamp: number;
-}
-
-/**
- * Discriminated union of {@link MiddlewareEvent} variants, one per
- * middleware in `TMiddleware`.  When the middleware array is typed,
- * `event.stateDelta` narrows to the middleware's inferred state type.
- *
- * Falls back to `MiddlewareEvent` (untyped) when the middleware array
- * is a plain `AgentMiddleware[]`.
- */
-export type MiddlewareEventUnion<
-  TMiddleware extends readonly AgentMiddleware[],
-> = {
-  [K in keyof TMiddleware]: TMiddleware[K] extends AgentMiddleware
-    ? MiddlewareEvent<InferMiddlewareState<TMiddleware[K]>>
-    : MiddlewareEvent;
-}[number];
-
 /**
  * A {@link GraphRunStream} with native agent-level projections assigned
  * directly on the instance by `createGraphRunStream` (via `__native`
@@ -156,13 +111,10 @@ export type AgentRunStream<
     | ClientTool
     | ServerTool
   )[],
-  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[],
   TExtensions extends Record<string, unknown> = Record<string, unknown>,
 > = GraphRunStream<TValues, TExtensions> & {
   /** Tool call streams from the native ToolCallTransformer. */
   toolCalls: AsyncIterable<ToolCallStreamUnion<TTools>>;
-  /** Middleware lifecycle events from the native MiddlewareTransformer. */
-  middleware: AsyncIterable<MiddlewareEventUnion<TMiddleware>>;
 };
 
 interface ToolCallProjection {
@@ -371,66 +323,3 @@ export function createToolCallTransformer(
     };
   };
 }
-
-interface MiddlewareProjection {
-  middleware: AsyncIterable<MiddlewareEvent>;
-}
-
-const MIDDLEWARE_NODE_PATTERN =
-  /^(.+)\.(before_agent|before_model|after_model|after_agent)$/;
-
-/**
- * Creates a native transformer that watches `updates` events from
- * middleware nodes and surfaces them as typed {@link MiddlewareEvent}
- * objects.
- *
- * Marked `__native: true` — projection key lands directly on the
- * `GraphRunStream` instance as `run.middleware`.
- */
-export function createMiddlewareTransformer(
-  path: Namespace
-): () => NativeStreamTransformer<MiddlewareProjection> {
-  return () => {
-    const middlewareLog = StreamChannel.local<MiddlewareEvent>();
-
-    return {
-      __native: true as const,
-
-      init: () => ({
-        middleware: middlewareLog,
-      }),
-
-      process(event: ProtocolEvent): boolean {
-        if (event.method !== "updates") return true;
-        if (!isOwnEvent(event.params.namespace, path)) return true;
-
-        const data = event.params.data as UpdatesEventData;
-        const nodeName = data.node ?? event.params.node;
-        if (!nodeName) return true;
-
-        const match = MIDDLEWARE_NODE_PATTERN.exec(nodeName);
-        if (!match) return true;
-
-        const name = match[1];
-        const phase = match[2] as MiddlewarePhase;
-
-        middlewareLog.push({
-          phase,
-          name,
-          stateDelta: data.values ?? {},
-          timestamp: event.params.timestamp,
-        });
-
-        return true;
-      },
-
-      finalize(): void {
-        middlewareLog.close();
-      },
-
-      fail(err: unknown): void {
-        middlewareLog.fail(err);
-      },
-    };
-  };
-}

libs/langchain/src/agents/tests/stream.int.test.ts

@@ -14,7 +14,7 @@ import { tool } from "@langchain/core/tools";
 import { AIMessage } from "@langchain/core/messages";
 import { Client } from "@langchain/langgraph-sdk";
 
-import { createMiddleware, createAgent } from "../index.js";
+import { createAgent } from "../index.js";
 
 const threads: ThreadSaver = (() => {
   const THREADS: Record<
@@ -55,24 +55,6 @@ const minusTool = tool(
     schema: z.object({ a: z.number(), b: z.number() }),
   }
 );
-const middlewareA = createMiddleware({
-  name: "trackerA",
-  stateSchema: z.object({
-    trackerState: z.string().default("init"),
-  }),
-  beforeModel: () => ({ trackerState: "before", before: true }),
-  afterModel: () => ({ trackerState: "after", after: true }),
-});
-
-const middlewareB = createMiddleware({
-  name: "trackerB",
-  stateSchema: z.object({
-    trackerState: z.string().default("init"),
-  }),
-  wrapModelCall: async (request, handler) => {
-    return await handler(request);
-  },
-});
 
 const model = fakeModel()
   .respondWithTools([
@@ -84,7 +66,6 @@ const model = fakeModel()
 const agent = createAgent({
   model,
   tools: [addTool, minusTool],
-  middleware: [middlewareA, middlewareB],
   // oxlint-disable-next-line typescript/no-explicit-any
 }) as unknown as Pregel<any, any, any, any, any>;
 
@@ -151,7 +132,7 @@ async function collectAllEvents(
 beforeAll(setup);
 
 describe("streamEvents", () => {
-  it("should emit stream evebts for each tool and middleware invocation", async () => {
+  it("should emit stream events for each tool invocation", async () => {
     console.log("url", url);
     const client = new Client({ apiUrl: url! });
 
@@ -234,14 +215,10 @@ describe("streamEvents", () => {
     expect(updates.length).toBe(8);
     const updateNodes = updates.map(nodeOf);
     expect(updateNodes).toEqual([
-      "trackerA.before_model",
       "model_request",
-      "trackerA.after_model",
       "tools",
       "tools",
-      "trackerA.before_model",
       "model_request",
-      "trackerA.after_model",
     ]);
 
     // first model_request produced tool calls
@@ -269,10 +246,6 @@ describe("streamEvents", () => {
       tool_call_id: "call_2",
     });
 
-    // middleware state transitions are reflected
-    expect(dataOf(updates[0]).trackerState).toBe("before");
-    expect(dataOf(updates[2]).trackerState).toBe("after");
-
     // --- values: 8 state snapshots ---
     const values = eventsByChannel.get("values") ?? [];
     expect(values.length).toBe(8);

libs/langchain/src/agents/tests/stream.test-d.ts

@@ -5,7 +5,7 @@ import { tool } from "@langchain/core/tools";
 import { fakeModel } from "@langchain/core/testing";
 import { StreamChannel, type StreamTransformer } from "@langchain/langgraph";
 
-import { createAgent, createMiddleware } from "../index.js";
+import { createAgent } from "../index.js";
 
 describe("streamEvents types", () => {
   it("should type tool calls as a discriminated union", async () => {
@@ -58,42 +58,6 @@ describe("streamEvents types", () => {
     }
   });
 
-  it("should type middleware events with inferred state delta", async () => {
-    const model = fakeModel().respond(new AIMessage("ok"));
-
-    const tracker = createMiddleware({
-      name: "tracker",
-      stateSchema: z.object({
-        trackerState: z.string().default("init"),
-      }),
-      beforeModel: () => ({ trackerState: "before" }),
-    });
-
-    const agent = createAgent({
-      model,
-      tools: [],
-      middleware: [tracker],
-    });
-
-    const run = await agent.streamEvents(
-      {
-        messages: [new HumanMessage("hi")],
-      },
-      { version: "v3" }
-    );
-
-    for await (const event of run.middleware) {
-      expectTypeOf(event.phase).toEqualTypeOf<
-        "before_model" | "after_model" | "before_agent" | "after_agent"
-      >();
-      expectTypeOf(event.name).toEqualTypeOf<string>();
-      expectTypeOf(event.stateDelta).toEqualTypeOf<{
-        trackerState: string;
-      }>();
-      expectTypeOf(event.timestamp).toEqualTypeOf<number>();
-    }
-  });
-
   it("should type run.extensions from streamTransformers registered at creation time", async () => {
     const model = fakeModel().respond(new AIMessage("ok"));