docs/build/snippets/python/code-samples/customization-middleware-js.mdx

<CodeGroup>
    ```ts Google
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "google-genai:gemini-3.6-flash",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts OpenAI
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "openai:gpt-5.5",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts Anthropic
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "anthropic:claude-sonnet-4-6",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts OpenRouter
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "openrouter:openrouter:z-ai/glm-5.2",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts Fireworks
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "fireworks:accounts/fireworks/models/glm-5p2",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts Baseten
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "baseten:zai-org/GLM-5.2",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```

    ```ts Ollama
    import { tool, createMiddleware } from "langchain";
    import { createDeepAgent } from "deepagents";
    import * as z from "zod";
    
    const getWeather = tool(
      ({ city }: { city: string }) => {
        return `The weather in ${city} is sunny.`;
      },
      {
        name: "get_weather",
        description: "Get the weather in a city.",
        schema: z.object({
          city: z.string(),
        }),
      },
    );
    
    let callCount = 0;
    
    const logToolCallsMiddleware = createMiddleware({
      name: "LogToolCallsMiddleware",
      wrapToolCall: async (request, handler) => {
        // Intercept and log every tool call - demonstrates cross-cutting concern
        callCount += 1;
        const toolName = request.toolCall.name;
    
        console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
        console.log(
          `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
        );
    
        // Execute the tool call
        const result = await handler(request);
    
        // Log the result
        console.log(`[Middleware] Tool call #${callCount} completed`);
    
        return result;
      },
    });
    
    const agent = await createDeepAgent({
      model: "ollama:north-mini-code-1.0",
      tools: [getWeather] as any,
      middleware: [logToolCallsMiddleware] as any,
    });
    ```
</CodeGroup>