@jalpp/mcp-adapter 0.1.3 → 0.3.0

package/README.md

@@ -1,29 +1,185 @@
-# mcp-adapter
+# @jalpp/mcp-adapter
 
-Lightweight adapter utilities for registering tools on an [MCP](https://modelcontextprotocol.io) server with full TypeScript type safety.
+Lightweight adapter utilities for registering tools on an [MCP](https://modelcontextprotocol.io) server with full TypeScript type safety. Supports manual tool registration and automatic HTTP endpoint-to-tool bridging with built-in auth, path variables, and method-specific adapters.
 
 ## Installation
 
 ```bash
-npm install mcp-adapter
+npm install @jalpp/mcp-adapter
 ```
 
-> **Peer dependency:** `@modelcontextprotocol/sdk >= 1.0.0` must be installed in your project.
+**Peer dependencies** — install these in your project if not already present:
 
-## Usage
+```bash
+npm install @modelcontextprotocol/sdk zod axios
+```
 
-### `toolAdapter`
+## Adapters
 
-Registers a typed tool on an `McpServer`. Input schema types flow through to the callback automatically — no manual type annotations needed.
+| Adapter | Method | Description |
+|---------|--------|-------------|
+| `toolAdapter` | any | Register a tool with a typed callback |
+| `toolContentAdapter` | — | Normalize a result into a `CallToolResult` |
+| `httpToolAdapter` | any | Register any HTTP endpoint as a tool |
+| `getToolAdapter` | GET | Register a GET endpoint — args → query params |
+| `postToolAdapter` | POST | Register a POST endpoint — args → request body |
+| `putToolAdapter` | PUT | Register a PUT endpoint — args → request body |
+| `patchToolAdapter` | PATCH | Register a PATCH endpoint — args → request body |
+| `deleteToolAdapter` | DELETE | Register a DELETE endpoint — args → query params |
 
-**With input schema:**
+---
+
+## Path Variables
+
+All HTTP adapters support `:paramName` path variable syntax. Any input arg whose name matches a path variable is interpolated into the URL and removed from query params / request body.
 
 ```ts
-import { toolAdapter, toolContentAdapter } from "mcp-adapter";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+getToolAdapter(server, {
+  name: "get-game-details",
+  description: "Fetch a game by ID",
+  endpoint: "https://api.example.com/games/:gameId",
+  inputSchema: {
+    gameId: z.string().describe("Game ID"),
+    expand: z.string().optional().describe("Optional fields to expand"),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// GET https://api.example.com/games/abc123?expand=moves
+```
+
+---
+
+## `getToolAdapter`
+
+Registers a GET endpoint as an MCP tool. Remaining args (after path variable interpolation) are sent as **query parameters**.
+
+```ts
+import { getToolAdapter } from "@jalpp/mcp-adapter";
 import z from "zod";
 
-const server = new McpServer({ name: "my-server", version: "1.0.0" });
+getToolAdapter(server, {
+  name: "get-user",
+  description: "Fetch a user by ID",
+  endpoint: "https://api.example.com/users/:userId",
+  inputSchema: {
+    userId: z.string().describe("User ID"),
+    expand: z.string().optional().describe("Comma-separated fields to expand"),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// → GET https://api.example.com/users/abc123?expand=profile
+```
+
+---
+
+## `postToolAdapter`
+
+Registers a POST endpoint as an MCP tool. Remaining args (after path variable interpolation) are sent as the **JSON request body**.
+
+```ts
+import { postToolAdapter } from "@jalpp/mcp-adapter";
+
+postToolAdapter(server, {
+  name: "create-post",
+  description: "Create a new post for a user",
+  endpoint: "https://api.example.com/users/:userId/posts",
+  inputSchema: {
+    userId: z.string().describe("User ID"),
+    title: z.string().describe("Post title"),
+    body: z.string().describe("Post body"),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// → POST https://api.example.com/users/abc123/posts  { title, body }
+```
+
+---
+
+## `putToolAdapter`
+
+Registers a PUT endpoint as an MCP tool. Remaining args are sent as the **JSON request body**.
+
+```ts
+putToolAdapter(server, {
+  name: "update-user",
+  description: "Replace a user record",
+  endpoint: "https://api.example.com/users/:userId",
+  inputSchema: {
+    userId: z.string(),
+    name: z.string(),
+    email: z.string(),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// → PUT https://api.example.com/users/abc123  { name, email }
+```
+
+---
+
+## `patchToolAdapter`
+
+Registers a PATCH endpoint as an MCP tool. Remaining args are sent as the **JSON request body**.
+
+```ts
+patchToolAdapter(server, {
+  name: "update-post-title",
+  description: "Partially update a post",
+  endpoint: "https://api.example.com/posts/:postId",
+  inputSchema: {
+    postId: z.string(),
+    title: z.string(),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// → PATCH https://api.example.com/posts/xyz789  { title }
+```
+
+---
+
+## `deleteToolAdapter`
+
+Registers a DELETE endpoint as an MCP tool. Remaining args (after path variable interpolation) are sent as **query parameters**.
+
+```ts
+deleteToolAdapter(server, {
+  name: "delete-post",
+  description: "Delete a post by ID",
+  endpoint: "https://api.example.com/posts/:postId",
+  inputSchema: { postId: z.string() },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// → DELETE https://api.example.com/posts/xyz789
+```
+
+---
+
+## `httpToolAdapter`
+
+Lower-level adapter that accepts an explicit `method` field. Use this when the method needs to be dynamic or you prefer a single unified call style.
+
+```ts
+import { httpToolAdapter } from "@jalpp/mcp-adapter";
+
+httpToolAdapter(server, {
+  name: "get-analysis",
+  description: "Fetch position analysis",
+  endpoint: "https://api.example.com/analyze",
+  method: "POST",
+  inputSchema: { fen: z.string(), depth: z.number() },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+```
+
+---
+
+## `toolAdapter`
+
+Registers a tool with a fully custom typed callback. Use when you need data transformation, custom error handling, or logic that goes beyond a single HTTP call.
+
+**With input schema:**
+
+```ts
+import { toolAdapter, toolContentAdapter } from "@jalpp/mcp-adapter";
 
 toolAdapter(server, {
   name: "get-analysis",
@@ -47,9 +203,7 @@ toolAdapter(server, {
 ```ts
 toolAdapter(server, {
   name: "get-status",
-  config: {
-    description: "Returns current server status",
-  },
+  config: { description: "Returns current server status" },
   cb: async () => {
     const { data, error } = await myService.getStatus();
     return toolContentAdapter(data ?? {}, error);
@@ -57,13 +211,13 @@ toolAdapter(server, {
 });
 ```
 
-### `toolContentAdapter`
+---
 
-Normalizes a service result into a `CallToolResult`. If `error` is defined it takes priority; otherwise `data` is pretty-printed as JSON.
+## `toolContentAdapter`
 
-```ts
-import { toolContentAdapter } from "mcp-adapter";
+Normalizes a result into a `CallToolResult` text block. If `error` is defined it takes priority; otherwise `data` is serialized as pretty-printed JSON.
 
+```ts
 return toolContentAdapter(data ?? {}, error);
 ```
 
@@ -72,18 +226,71 @@ return toolContentAdapter(data ?? {}, error);
 | `data` | `object` | Successful result payload |
 | `error` | `string \| undefined` | Error message — takes priority over `data` |
 
-## API
+---
+
+## Authentication
+
+All HTTP adapters accept an optional `auth` field. Three strategies are supported:
+
+**Bearer token** — `Authorization: Bearer <token>`:
+```ts
+auth: { type: "bearer", token: process.env.API_TOKEN! }
+```
+
+**API key** — custom header:
+```ts
+auth: { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! }
+```
+
+**Basic auth** — `Authorization: Basic <base64>`:
+```ts
+auth: { type: "basic", username: "user", password: process.env.PASSWORD! }
+```
+
+---
+
+## Extra axios config
+
+Pass any [axios request config](https://axios-http.com/docs/req_config) via `axiosConfig`:
+
+```ts
+getToolAdapter(server, {
+  name: "get-data",
+  description: "Fetch with custom timeout",
+  endpoint: "https://api.example.com/data",
+  axiosConfig: { timeout: 5000 },
+});
+```
+
+---
+
+## API Reference
+
+### Method-specific adapters
+
+| Function | Method | Args mapping |
+|----------|--------|--------------|
+| `getToolAdapter` | GET | remaining args → query params |
+| `postToolAdapter` | POST | remaining args → request body |
+| `putToolAdapter` | PUT | remaining args → request body |
+| `patchToolAdapter` | PATCH | remaining args → request body |
+| `deleteToolAdapter` | DELETE | remaining args → query params |
+
+All support optional `inputSchema` and `:paramName` path variables.
+
+### Auth types
 
-### `toolAdapter(server, adapter)`
+| Type | Interface | Fields |
+|------|-----------|--------|
+| Bearer | `BearerAuth` | `token` |
+| API Key | `ApiKeyAuth` | `header`, `key` |
+| Basic | `BasicAuth` | `username`, `password` |
 
-| Overload | Description |
-|----------|-------------|
-| `toolAdapter<T>(server, ToolInputAdapterWithSchema<T>)` | Tool with typed input schema |
-| `toolAdapter(server, ToolInputAdapterWithoutSchema)` | Tool with no input arguments |
+---
 
-### `toolContentAdapter(data, error)`
+## Repository
 
-Returns a `CallToolResult` with a single `text` content block.
+[github.com/jalpp/mcp-adapter](https://github.com/jalpp/mcp-adapter)
 
 ## License
 

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { McpServer, ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import { ToolAnnotations, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { AxiosRequestConfig } from 'axios';
 
 /**
  * Adapter input for registering a tool that declares an input schema.
@@ -92,4 +93,243 @@ declare function toolAdapter<T extends ZodRawShapeCompat>(server: McpServer, too
  */
 declare function toolAdapter(server: McpServer, toolInputAdapter: ToolInputAdapterWithoutSchema): void;
 
-export { toolAdapter, toolContentAdapter };
+/**
+ * Supported HTTP methods for the HTTP tool adapter.
+ */
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/**
+ * API key authentication — sent as a request header.
+ * @example { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! }
+ */
+interface ApiKeyAuth {
+    type: "apikey";
+    /** Header name to send the key in (e.g. `"X-API-Key"`) */
+    header: string;
+    key: string;
+}
+/**
+ * Bearer token authentication — sends `Authorization: Bearer <token>`.
+ * @example { type: "bearer", token: process.env.API_TOKEN! }
+ */
+interface BearerAuth {
+    type: "bearer";
+    token: string;
+}
+/**
+ * HTTP Basic authentication — sends `Authorization: Basic <base64>`.
+ * @example { type: "basic", username: "user", password: process.env.PASSWORD! }
+ */
+interface BasicAuth {
+    type: "basic";
+    username: string;
+    password: string;
+}
+/** Union of all supported authentication strategies. */
+type HttpAuth = ApiKeyAuth | BearerAuth | BasicAuth;
+/**
+ * Configuration for registering an HTTP endpoint as an MCP tool with an input schema.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+interface HttpToolAdapterWithSchema<T extends ZodRawShapeCompat> {
+    /** Unique tool name in the MCP registry. */
+    name: string;
+    /** Description of the tool shown to the model. */
+    description: string;
+    /**
+     * Full URL of the API endpoint. Supports path variable templates using `:paramName` syntax.
+     * @example "https://api.example.com/users/:userId/posts"
+     */
+    endpoint: string;
+    /** HTTP method to use. */
+    method: HttpMethod;
+    /** Zod shape defining the tool's input arguments. */
+    inputSchema: T;
+    /** Optional authentication strategy. */
+    auth?: HttpAuth;
+    /** Optional extra axios config (e.g. headers, timeout). */
+    axiosConfig?: AxiosRequestConfig;
+}
+/**
+ * Configuration for registering an HTTP endpoint as an MCP tool with no input arguments.
+ */
+interface HttpToolAdapterWithoutSchema {
+    /** Unique tool name in the MCP registry. */
+    name: string;
+    /** Description of the tool shown to the model. */
+    description: string;
+    /**
+     * Full URL of the API endpoint. Supports path variable templates using `:paramName` syntax.
+     * @example "https://api.example.com/status"
+     */
+    endpoint: string;
+    /** HTTP method to use. */
+    method: HttpMethod;
+    inputSchema?: undefined;
+    /** Optional authentication strategy. */
+    auth?: HttpAuth;
+    /** Optional extra axios config (e.g. headers, timeout). */
+    axiosConfig?: AxiosRequestConfig;
+}
+/**
+ * Configuration specific to GET tool adapters.
+ * Input args are mapped to query parameters unless consumed by path variables.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+type GetToolAdapterConfig<T extends ZodRawShapeCompat> = Omit<HttpToolAdapterWithSchema<T>, "method">;
+/**
+ * Configuration specific to GET tool adapters without input schema.
+ */
+type GetToolAdapterConfigNoSchema = Omit<HttpToolAdapterWithoutSchema, "method">;
+/**
+ * Configuration specific to POST tool adapters.
+ * Input args are sent as the JSON request body unless consumed by path variables.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+type PostToolAdapterConfig<T extends ZodRawShapeCompat> = Omit<HttpToolAdapterWithSchema<T>, "method">;
+/**
+ * Configuration specific to POST tool adapters without input schema.
+ */
+type PostToolAdapterConfigNoSchema = Omit<HttpToolAdapterWithoutSchema, "method">;
+/**
+ * Configuration specific to PUT tool adapters.
+ * Input args are sent as the JSON request body unless consumed by path variables.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+type PutToolAdapterConfig<T extends ZodRawShapeCompat> = Omit<HttpToolAdapterWithSchema<T>, "method">;
+/**
+ * Configuration specific to PATCH tool adapters.
+ * Input args are sent as the JSON request body unless consumed by path variables.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+type PatchToolAdapterConfig<T extends ZodRawShapeCompat> = Omit<HttpToolAdapterWithSchema<T>, "method">;
+/**
+ * Configuration specific to DELETE tool adapters.
+ * Input args are sent as query parameters unless consumed by path variables.
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ */
+type DeleteToolAdapterConfig<T extends ZodRawShapeCompat> = Omit<HttpToolAdapterWithSchema<T>, "method">;
+/**
+ * Core HTTP tool adapter. Registers any HTTP endpoint as an MCP tool.
+ *
+ * Prefer the method-specific adapters (`getToolAdapter`, `postToolAdapter`, etc.)
+ * for cleaner, self-documenting code.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - GET/DELETE: remaining args → query parameters.
+ * - POST/PUT/PATCH: remaining args → JSON request body.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server  - The `McpServer` instance to register the tool on.
+ * @param adapter - HTTP tool configuration.
+ */
+declare function httpToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, adapter: HttpToolAdapterWithSchema<T>): void;
+declare function httpToolAdapter(server: McpServer, adapter: HttpToolAdapterWithoutSchema): void;
+/**
+ * Registers a GET endpoint as an MCP tool.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - Remaining args are sent as **query parameters**.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server - The `McpServer` instance to register the tool on.
+ * @param config - Tool configuration without `method`.
+ *
+ * @example
+ * getToolAdapter(server, {
+ *   name: "get-user",
+ *   description: "Fetch a user by ID",
+ *   endpoint: "https://api.example.com/users/:userId",
+ *   inputSchema: { userId: z.string(), expand: z.string().optional() },
+ *   auth: { type: "bearer", token: process.env.API_TOKEN! },
+ * });
+ * // GET https://api.example.com/users/abc123?expand=profile
+ */
+declare function getToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: GetToolAdapterConfig<T>): void;
+declare function getToolAdapter(server: McpServer, config: GetToolAdapterConfigNoSchema): void;
+/**
+ * Registers a POST endpoint as an MCP tool.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - Remaining args are sent as the **JSON request body**.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server - The `McpServer` instance to register the tool on.
+ * @param config - Tool configuration without `method`.
+ *
+ * @example
+ * postToolAdapter(server, {
+ *   name: "create-post",
+ *   description: "Create a new post for a user",
+ *   endpoint: "https://api.example.com/users/:userId/posts",
+ *   inputSchema: { userId: z.string(), title: z.string(), body: z.string() },
+ *   auth: { type: "bearer", token: process.env.API_TOKEN! },
+ * });
+ * // POST https://api.example.com/users/abc123/posts  { title, body }
+ */
+declare function postToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: PostToolAdapterConfig<T>): void;
+declare function postToolAdapter(server: McpServer, config: PostToolAdapterConfigNoSchema): void;
+/**
+ * Registers a PUT endpoint as an MCP tool.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - Remaining args are sent as the **JSON request body**.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server - The `McpServer` instance to register the tool on.
+ * @param config - Tool configuration without `method`.
+ *
+ * @example
+ * putToolAdapter(server, {
+ *   name: "update-user",
+ *   description: "Replace a user record",
+ *   endpoint: "https://api.example.com/users/:userId",
+ *   inputSchema: { userId: z.string(), name: z.string(), email: z.string() },
+ *   auth: { type: "bearer", token: process.env.API_TOKEN! },
+ * });
+ * // PUT https://api.example.com/users/abc123  { name, email }
+ */
+declare function putToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: PutToolAdapterConfig<T>): void;
+/**
+ * Registers a PATCH endpoint as an MCP tool.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - Remaining args are sent as the **JSON request body**.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server - The `McpServer` instance to register the tool on.
+ * @param config - Tool configuration without `method`.
+ *
+ * @example
+ * patchToolAdapter(server, {
+ *   name: "update-post-title",
+ *   description: "Partially update a post",
+ *   endpoint: "https://api.example.com/posts/:postId",
+ *   inputSchema: { postId: z.string(), title: z.string() },
+ *   auth: { type: "bearer", token: process.env.API_TOKEN! },
+ * });
+ * // PATCH https://api.example.com/posts/xyz789  { title }
+ */
+declare function patchToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: PatchToolAdapterConfig<T>): void;
+/**
+ * Registers a DELETE endpoint as an MCP tool.
+ *
+ * - Path variables (`:paramName`) are interpolated from input args.
+ * - Remaining args are sent as **query parameters**.
+ *
+ * @template T - Zod raw shape inferred from `inputSchema`.
+ * @param server - The `McpServer` instance to register the tool on.
+ * @param config - Tool configuration without `method`.
+ *
+ * @example
+ * deleteToolAdapter(server, {
+ *   name: "delete-post",
+ *   description: "Delete a post by ID",
+ *   endpoint: "https://api.example.com/posts/:postId",
+ *   inputSchema: { postId: z.string() },
+ *   auth: { type: "bearer", token: process.env.API_TOKEN! },
+ * });
+ * // DELETE https://api.example.com/posts/xyz789
+ */
+declare function deleteToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: DeleteToolAdapterConfig<T>): void;
+
+export { type ApiKeyAuth, type BasicAuth, type BearerAuth, type DeleteToolAdapterConfig, type GetToolAdapterConfig, type GetToolAdapterConfigNoSchema, type HttpAuth, type HttpMethod, type HttpToolAdapterWithSchema, type HttpToolAdapterWithoutSchema, type PatchToolAdapterConfig, type PostToolAdapterConfig, type PostToolAdapterConfigNoSchema, type PutToolAdapterConfig, deleteToolAdapter, getToolAdapter, httpToolAdapter, patchToolAdapter, postToolAdapter, putToolAdapter, toolAdapter, toolContentAdapter };

package/dist/index.js

@@ -24,7 +24,110 @@ function toolAdapter(server, toolInputAdapter) {
     );
   }
 }
+
+// src/axiosAdapter.ts
+import axios from "axios";
+function buildAuthHeaders(auth) {
+  switch (auth.type) {
+    case "apikey":
+      return { [auth.header]: auth.key };
+    case "bearer":
+      return { Authorization: `Bearer ${auth.token}` };
+    case "basic": {
+      const encoded = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+      return { Authorization: `Basic ${encoded}` };
+    }
+  }
+}
+function resolvePathParams(endpoint, args) {
+  const remainingArgs = { ...args };
+  const url = endpoint.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {
+    if (key in remainingArgs) {
+      const value = remainingArgs[key];
+      delete remainingArgs[key];
+      return encodeURIComponent(String(value));
+    }
+    return `:${key}`;
+  });
+  return { url, remainingArgs };
+}
+async function executeRequest(endpoint, method, args, auth, extraConfig) {
+  try {
+    const authHeaders = auth ? buildAuthHeaders(auth) : {};
+    const { url, remainingArgs } = resolvePathParams(endpoint, args);
+    const isQueryMethod = method === "GET" || method === "DELETE";
+    const config = {
+      url,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders,
+        ...extraConfig?.headers
+      },
+      ...isQueryMethod ? { params: remainingArgs } : { data: remainingArgs },
+      ...extraConfig
+    };
+    const response = await axios(config);
+    return { data: response.data };
+  } catch (err) {
+    if (axios.isAxiosError(err)) {
+      const status = err.response?.status ?? "unknown";
+      const message = err.response?.data?.message ?? err.message;
+      return { error: `HTTP ${status}: ${message}` };
+    }
+    return { error: `Unexpected error: ${String(err)}` };
+  }
+}
+function httpToolAdapter(server, adapter) {
+  if (adapter.inputSchema) {
+    const { endpoint, method, auth, axiosConfig, inputSchema } = adapter;
+    toolAdapter(server, {
+      name: adapter.name,
+      config: { description: adapter.description, inputSchema },
+      cb: (async (args) => {
+        const { data, error } = await executeRequest(endpoint, method, args, auth, axiosConfig);
+        return toolContentAdapter(data ?? {}, error);
+      })
+    });
+  } else {
+    toolAdapter(server, {
+      name: adapter.name,
+      config: { description: adapter.description },
+      cb: async () => {
+        const { data, error } = await executeRequest(
+          adapter.endpoint,
+          adapter.method,
+          {},
+          adapter.auth,
+          adapter.axiosConfig
+        );
+        return toolContentAdapter(data ?? {}, error);
+      }
+    });
+  }
+}
+function getToolAdapter(server, config) {
+  httpToolAdapter(server, { ...config, method: "GET" });
+}
+function postToolAdapter(server, config) {
+  httpToolAdapter(server, { ...config, method: "POST" });
+}
+function putToolAdapter(server, config) {
+  httpToolAdapter(server, { ...config, method: "PUT" });
+}
+function patchToolAdapter(server, config) {
+  httpToolAdapter(server, { ...config, method: "PATCH" });
+}
+function deleteToolAdapter(server, config) {
+  httpToolAdapter(server, { ...config, method: "DELETE" });
+}
 export {
+  deleteToolAdapter,
+  getToolAdapter,
+  httpToolAdapter,
+  patchToolAdapter,
+  postToolAdapter,
+  putToolAdapter,
   toolAdapter,
   toolContentAdapter
 };

package/package.json

@@ -1,13 +1,27 @@
 {
   "name": "@jalpp/mcp-adapter",
-  "version": "0.1.3",
-  "description": "Adapter utilities for registering MCP tools",
+  "version": "0.3.0",
+  "description": "Adapter utilities for registering MCP tools with full TypeScript type safety — supports typed callbacks and automatic HTTP endpoint bridging with auth",
   "author": "jalpp",
   "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "adapter",
+    "llm",
+    "typescript",
+    "axios",
+    "http",
+    "tool"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jalpp/mcp-adapter.git"
   },
+  "homepage": "https://github.com/jalpp/mcp-adapter#readme",
+  "bugs": {
+    "url": "https://github.com/jalpp/mcp-adapter/issues"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,7 +33,9 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
@@ -28,13 +44,17 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.0.0",
-    "zod": ">=3.0.0"
+    "zod": ">=3.0.0",
+    "axios": ">=1.0.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": ">=1.0.0",
-    "zod": ">=3.0.0",
-    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
-    "@types/node": "^20.0.0"
+    "typescript": "^5.0.0",
+    "zod": ">=3.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.13.6"
   }
 }