langchain.js
    Preparing search index...

    Function createMiddleware

    • Creates a middleware instance with automatic schema inference.

      Type Parameters

      • TSchema extends any = undefined
      • TContextSchema extends any = undefined

      Parameters

      • config: {
            afterAgent?: AfterAgentHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
            afterModel?: AfterModelHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
            beforeAgent?: BeforeAgentHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
            beforeModel?: BeforeModelHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
            contextSchema?: TContextSchema;
            name: string;
            stateSchema?: TSchema;
            tools?: any[];
            wrapModelCall?: WrapModelCallHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
            wrapToolCall?: WrapToolCallHook<
                TSchema,
                NormalizeContextSchema<TContextSchema>,
            >;
        }

        Middleware configuration

        • OptionalafterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>

          The function to run after the agent execution completes. This function is called once at the end of the agent invocation. It allows to modify the final state of the agent after all model calls and tool executions are complete.

          The middleware state

          The middleware runtime

          The modified middleware state or undefined to pass through

        • OptionalafterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>

          The function to run after the model call. This function is called after the model is invoked and before any tools are called. It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.

          The middleware state

          The middleware runtime

          The modified middleware state or undefined to pass through

        • OptionalbeforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>

          The function to run before the agent execution starts. This function is called once at the start of the agent invocation. It allows to modify the state of the agent before any model calls or tool executions.

          The middleware state

          The middleware runtime

          The modified middleware state or undefined to pass through

        • OptionalbeforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>

          The function to run before the model call. This function is called before the model is invoked and before the wrapModelCall hook. It allows to modify the state of the agent.

          The middleware state

          The middleware runtime

          The modified middleware state or undefined to pass through

        • OptionalcontextSchema?: TContextSchema

          The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:

          • A Zod object
          • A Zod optional object
          • A Zod default object
          • Undefined
        • name: string

          The name of the middleware

        • OptionalstateSchema?: TSchema

          The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:

          • A Zod object
          • A Zod optional object
          • A Zod default object
          • Undefined
        • Optionaltools?: any[]

          Additional tools registered by the middleware.

        • OptionalwrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>

          Wraps the model invocation with custom logic. This allows you to:

          • Modify the request before calling the model
          • Handle errors and retry with different parameters
          • Post-process the response
          • Implement custom caching, logging, or other cross-cutting concerns

          The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.

          The model request containing all the parameters needed.

          The function that invokes the model. Call this with a ModelRequest to get the response.

          The response from the model (or a modified version).

          wrapModelCall: async (request, handler) => {
            // Modify request before calling
            const modifiedRequest = { ...request, systemPrompt: "You are helpful" };

            try {
              // Call the model
              return await handler(modifiedRequest);
            } catch (error) {
              // Handle errors and retry with fallback
              const fallbackRequest = { ...request, model: fallbackModel };
              return await handler(fallbackRequest);
            }
          }
        • OptionalwrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>

          Wraps tool execution with custom logic. This allows you to:

          • Modify tool call parameters before execution
          • Handle errors and retry with different parameters
          • Post-process tool results
          • Implement caching, logging, authentication, or other cross-cutting concerns
          • Return Command objects for advanced control flow

          The handler receives a ToolCallRequest containing the tool call, state, and runtime, along with a handler function to execute the actual tool.

          The tool call request containing toolCall, state, and runtime.

          The function that executes the tool. Call this with a ToolCallRequest to get the result.

          The tool result as a ToolMessage or a Command for advanced control flow.

          wrapToolCall: async (request, handler) => {
            console.log(`Calling tool: ${request.tool.name}`);
            console.log(`Tool description: ${request.tool.description}`);

            try {
              // Execute the tool
              const result = await handler(request);
              console.log(`Tool ${request.tool.name} succeeded`);
              return result;
            } catch (error) {
              console.error(`Tool ${request.tool.name} failed:`, error);
              // Could return a custom error message or retry
              throw error;
            }
          }

          wrapToolCall: async (request, handler) => {
            // Check if user is authorized for this tool
            if (!request.runtime.context.isAuthorized(request.tool.name)) {
              return new ToolMessage({
                content: "Unauthorized to call this tool",
                tool_call_id: request.toolCall.id,
              });
            }
            return handler(request);
          }

      Returns AgentMiddleware<TSchema, TContextSchema, any>

      A middleware instance

      const authMiddleware = createMiddleware({
        name: "AuthMiddleware",
        stateSchema: z.object({
          isAuthenticated: z.boolean().default(false),
        }),
        contextSchema: z.object({
          userId: z.string(),
        }),
        beforeModel: async (state, runtime, controls) => {
          if (!state.isAuthenticated) {
            return controls.terminate(new Error("Not authenticated"));
          }
        },
      });

    Settings

    Member Visibility