How do you wrap a REST API call with auth headers inside a Tool in TypeScript?

Question

Accepted Answer

To create a secure, reusable LangChain tool that interacts with a protected REST API, you should use the `tool()` factory function. This function creates a `StructuredTool` that accepts a Zod schema for input validation and an asynchronous function containing the fetch logic. The key to authentication is manually adding an `Authorization` header (or any required custom headers) to the `fetch` request inside the tool's `func`. This approach gives you full control over the request, including error handling and response parsing, which is more flexible than trying to configure headers on pre-built request tools . import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Define the input schema using Zod. This ensures the tool receives valid data.
const userProfileSchema = z.object({
  userId: z.string().describe("The unique identifier of the user to fetch."),
});

// Create the tool. The `func` contains the core logic.
const getUserProfileTool = tool(
  async ({ userId }) => {
    // 1. Retrieve the API token from environment variables.
    const apiToken = process.env.MY_API_TOKEN;
    if (!apiToken) {
      throw new Error("API token is not configured.");
    }

// 2. Construct the API endpoint URL.
    const url = `https://api.example.com/v1/users/${userId}`;

try {
      // 3. Make the fetch request, including the Authorization header.
      const response = await fetch(url, {
        method: "GET",
        headers: {
          "Authorization": `Bearer ${apiToken}`, // Injecting the auth header
          "Content-Type": "application/json",
        },
      });

// 4. Handle non-2xx HTTP responses.
      if (!response.ok) {
        throw new Error(`API request failed with status ${response.status}`);
      }

// 5. Parse and return the JSON response.
      const userData = await response.json();
      return JSON.stringify(userData);
    } catch (error) {
      // 6. Log and re-throw the error so the agent can handle it.
      console.error(`Failed to fetch user ${userId}:`, error);
      throw new Error(`Could not retrieve user profile: ${error.message}`);
    }
  },
  {
    name: "get_user_profile",
    description: "Fetches the profile information for a given user ID from the internal API.",
    schema: userProfileSchema,
  }
); This method provides complete control over the request, making it robust for production. The API token is securely injected from environment variables at runtime, preventing hardcoding. The tool also includes structured error handling, which is critical for agents to function reliably when external services fail. This pattern is universally applicable, whether you're using a bearer token, API key, or any other authentication scheme. Simply modify the `headers` object in the `fetch` call to match your API's requirements. **Context**: As an alternative, you could use a pre-built tool like the `RequestsGetTool` and try to configure its internal request wrapper. However, this approach is generally less flexible and reliable than building a custom tool. **Example**: Based on a community discussion, you might attempt to access a tool's internal request wrapper to update its headers . While this can work for simple cases, it is less discoverable and can break if the internal structure of the tool changes in future library versions. **Code Snippet (Less Recommended)**:
```typescript
// This is a less robust, exploratory pattern.
import { RequestsGetTool } from "langchain/tools";

const tools = [new RequestsGetTool()];
const requestTool = tools[0];

// Attempt to modify the internal wrapper's headers (structure is not guaranteed).
if (requestTool.requests_wrapper) {
  requestTool.requests_wrapper.headers['Authorization'] = `Bearer ${process.env.API_KEY}`;
}
``` In summary, for wrapping a REST API call with authentication in TypeScript, the custom `tool()` approach is the most robust, type-safe, and maintainable method. It provides full control over the request and response lifecycle, which is essential for integrating with any protected external service in a LangChain agent.

How do you wrap a REST API call with auth headers inside a Tool in TypeScript?

You wrap a REST API call with auth headers in TypeScript by using the `tool()` helper from `@langchain/core/tools`, defining a Zod schema for the tool's input, and implementing the `func` to make an authenticated `fetch` request that includes the required `Authorization` header.

How do you wrap a REST API call with auth headers inside a Tool in TypeScript?

You wrap a REST API call with auth headers in TypeScript by using the `tool()` helper from `@langchain/core/tools`, defining a Zod schema for the tool's input, and implementing the `func` to make an authenticated `fetch` request that includes the required `Authorization` header.

Scenario Questions

Follow-up Questions

How do you wrap a REST API call with auth headers inside a Tool in TypeScript?

You wrap a REST API call with auth headers in TypeScript by using the tool() helper from @langchain/core/tools, defining a Zod schema for the tool's input, and implementing the func to make an authenticated fetch request that includes the required Authorization header.

How do you wrap a REST API call with auth headers inside a Tool in TypeScript?

You wrap a REST API call with auth headers in TypeScript by using the tool() helper from @langchain/core/tools, defining a Zod schema for the tool's input, and implementing the func to make an authenticated fetch request that includes the required Authorization header.

Scenario Questions

Follow-up Questions

You wrap a REST API call with auth headers in TypeScript by using the `tool()` helper from `@langchain/core/tools`, defining a Zod schema for the tool's input, and implementing the `func` to make an authenticated `fetch` request that includes the required `Authorization` header.

You wrap a REST API call with auth headers in TypeScript by using the `tool()` helper from `@langchain/core/tools`, defining a Zod schema for the tool's input, and implementing the `func` to make an authenticated `fetch` request that includes the required `Authorization` header.