@jalpp/mcp-adapter 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @jalpp/mcp-adapter
 
-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.
+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
 
@@ -16,26 +16,170 @@ npm install @modelcontextprotocol/sdk zod axios
 
 ## Adapters
 
-| Adapter | Description |
-|---------|-------------|
-| `toolAdapter` | Register a tool with a typed callback |
-| `toolContentAdapter` | Normalize a result into a `CallToolResult` |
-| `httpToolAdapter` | Register an HTTP endpoint directly as a tool |
+| 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 |
+
+---
+
+## 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
+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";
+
+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 typed tool on an `McpServer`. Input schema types flow through to the callback automatically — no manual type annotations needed.
+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";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import z from "zod";
-
-const server = new McpServer({ name: "my-server", version: "1.0.0" });
 
 toolAdapter(server, {
   name: "get-analysis",
@@ -59,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);
@@ -73,108 +215,50 @@ toolAdapter(server, {
 
 ## `toolContentAdapter`
 
-Normalizes a service result into a `CallToolResult` text block. If `error` is defined it takes priority; otherwise `data` is serialized as pretty-printed JSON.
+Normalizes a result into a `CallToolResult` text block. If `error` is defined it takes priority; otherwise `data` is serialized as pretty-printed JSON.
 
 ```ts
-import { toolContentAdapter } from "@jalpp/mcp-adapter";
-
 return toolContentAdapter(data ?? {}, error);
 ```
 
 | Argument | Type | Description |
 |----------|------|-------------|
 | `data` | `object` | Successful result payload |
-| `error` | `string \| undefined` | Error message — takes priority over `data` when present |
+| `error` | `string \| undefined` | Error message — takes priority over `data` |
 
 ---
 
-## `httpToolAdapter`
-
-Registers an HTTP endpoint directly as an MCP tool. Handles the full request lifecycle — auth headers, query params vs request body, and error mapping — so you only need to declare the tool metadata and schema.
-
-- **GET** requests map input args to **query parameters**
-- **POST / PUT / PATCH / DELETE** map input args to the **JSON request body**
-
-**With input schema:**
-
-```ts
-import { httpToolAdapter } from "@jalpp/mcp-adapter";
-import z from "zod";
+## Authentication
 
-httpToolAdapter(server, {
-  name: "get-analysis",
-  description: "Fetch position analysis from external API",
-  endpoint: "https://api.example.com/analyze",
-  method: "POST",
-  inputSchema: {
-    fen: z.string().describe("FEN string"),
-    depth: z.number().min(1).max(20),
-  },
-  auth: {
-    type: "bearer",
-    token: process.env.API_TOKEN!,
-  },
-});
-```
-
-**Without input schema:**
+All HTTP adapters accept an optional `auth` field. Three strategies are supported:
 
+**Bearer token** — `Authorization: Bearer <token>`:
 ```ts
-httpToolAdapter(server, {
-  name: "get-server-status",
-  description: "Fetch API health status",
-  endpoint: "https://api.example.com/status",
-  method: "GET",
-});
+auth: { type: "bearer", token: process.env.API_TOKEN! }
 ```
 
-### Authentication
-
-Three auth strategies are supported, all passed via the `auth` field:
-
-**Bearer token** — sends `Authorization: Bearer <token>`:
-
+**API key** — custom header:
 ```ts
-auth: {
-  type: "bearer",
-  token: process.env.API_TOKEN!,
-}
+auth: { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! }
 ```
 
-**API key** — sends the key in a custom header:
-
+**Basic auth** — `Authorization: Basic <base64>`:
 ```ts
-auth: {
-  type: "apikey",
-  header: "X-API-Key",
-  key: process.env.API_KEY!,
-}
+auth: { type: "basic", username: "user", password: process.env.PASSWORD! }
 ```
 
-**Basic auth** — sends `Authorization: Basic <base64(username:password)>`:
-
-```ts
-auth: {
-  type: "basic",
-  username: "myuser",
-  password: process.env.PASSWORD!,
-}
-```
+---
 
-### Extra axios config
+## Extra axios config
 
-Pass any additional [axios request config](https://axios-http.com/docs/req_config) via `axiosConfig`:
+Pass any [axios request config](https://axios-http.com/docs/req_config) via `axiosConfig`:
 
 ```ts
-httpToolAdapter(server, {
+getToolAdapter(server, {
   name: "get-data",
   description: "Fetch with custom timeout",
   endpoint: "https://api.example.com/data",
-  method: "GET",
-  axiosConfig: {
-    timeout: 5000,
-    headers: { "Accept-Language": "en" },
-  },
+  axiosConfig: { timeout: 5000 },
 });
 ```
 
@@ -182,23 +266,17 @@ httpToolAdapter(server, {
 
 ## API Reference
 
-### `toolAdapter(server, adapter)`
-
-| Overload | When to use |
-|----------|-------------|
-| `toolAdapter<T>(server, ToolInputAdapterWithSchema<T>)` | Tool that receives typed input args |
-| `toolAdapter(server, ToolInputAdapterWithoutSchema)` | Tool that takes no input |
-
-### `toolContentAdapter(data, error)`
-
-Returns a `CallToolResult` with a single `text` content block.
+### Method-specific adapters
 
-### `httpToolAdapter(server, adapter)`
+| 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 |
 
-| Overload | When to use |
-|----------|-------------|
-| `httpToolAdapter<T>(server, HttpToolAdapterWithSchema<T>)` | Endpoint that receives typed input args |
-| `httpToolAdapter(server, HttpToolAdapterWithoutSchema)` | Endpoint that takes no input |
+All support optional `inputSchema` and `:paramName` path variables.
 
 ### Auth types
 

package/dist/index.d.ts

@@ -124,23 +124,23 @@ interface BasicAuth {
     username: string;
     password: string;
 }
-/**
- * Union of all supported authentication strategies.
- */
+/** 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`, typed through to the request.
+ * @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. */
+    /**
+     * 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. GET maps args to query params; others map to request body. */
+    /** HTTP method to use. */
     method: HttpMethod;
     /** Zod shape defining the tool's input arguments. */
     inputSchema: T;
@@ -157,7 +157,10 @@ interface HttpToolAdapterWithoutSchema {
     name: string;
     /** Description of the tool shown to the model. */
     description: string;
-    /** Full URL of the API endpoint. */
+    /**
+     * 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;
@@ -168,41 +171,165 @@ interface HttpToolAdapterWithoutSchema {
     axiosConfig?: AxiosRequestConfig;
 }
 /**
- * Registers an HTTP endpoint as an MCP tool with a typed input schema.
+ * 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.
  *
- * GET requests map input args to query parameters.
- * All other methods map input args to the JSON request body.
+ * - 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 including endpoint, method, schema, and auth.
+ * @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
- * httpToolAdapter(server, {
- *   name: "get-analysis",
- *   description: "Fetch position analysis",
- *   endpoint: "https://api.example.com/analyze",
- *   method: "POST",
- *   inputSchema: { fen: z.string(), depth: z.number() },
+ * 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 httpToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, adapter: HttpToolAdapterWithSchema<T>): void;
+declare function getToolAdapter<T extends ZodRawShapeCompat>(server: McpServer, config: GetToolAdapterConfig<T>): void;
+declare function getToolAdapter(server: McpServer, config: GetToolAdapterConfigNoSchema): void;
 /**
- * Registers an HTTP endpoint as an MCP tool with no input arguments.
+ * Registers a POST endpoint as an MCP tool.
  *
- * @param server  - The `McpServer` instance to register the tool on.
- * @param adapter - HTTP tool configuration including endpoint, method, and auth.
+ * - 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
- * httpToolAdapter(server, {
- *   name: "get-status",
- *   description: "Fetch API status",
- *   endpoint: "https://api.example.com/status",
- *   method: "GET",
- *   auth: { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! },
+ * 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 httpToolAdapter(server: McpServer, adapter: HttpToolAdapterWithoutSchema): void;
+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 HttpAuth, type HttpMethod, type HttpToolAdapterWithSchema, type HttpToolAdapterWithoutSchema, httpToolAdapter, toolAdapter, toolContentAdapter };
+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

@@ -39,18 +39,32 @@ function buildAuthHeaders(auth) {
     }
   }
 }
+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: endpoint,
+      url,
       method,
       headers: {
         "Content-Type": "application/json",
         ...authHeaders,
         ...extraConfig?.headers
       },
-      ...method === "GET" ? { params: args } : { data: args },
+      ...isQueryMethod ? { params: remainingArgs } : { data: remainingArgs },
       ...extraConfig
     };
     const response = await axios(config);
@@ -69,10 +83,7 @@ function httpToolAdapter(server, adapter) {
     const { endpoint, method, auth, axiosConfig, inputSchema } = adapter;
     toolAdapter(server, {
       name: adapter.name,
-      config: {
-        description: adapter.description,
-        inputSchema
-      },
+      config: { description: adapter.description, inputSchema },
       cb: (async (args) => {
         const { data, error } = await executeRequest(endpoint, method, args, auth, axiosConfig);
         return toolContentAdapter(data ?? {}, error);
@@ -81,9 +92,7 @@ function httpToolAdapter(server, adapter) {
   } else {
     toolAdapter(server, {
       name: adapter.name,
-      config: {
-        description: adapter.description
-      },
+      config: { description: adapter.description },
       cb: async () => {
         const { data, error } = await executeRequest(
           adapter.endpoint,
@@ -97,8 +106,28 @@ function httpToolAdapter(server, adapter) {
     });
   }
 }
+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,6 +1,6 @@
 {
   "name": "@jalpp/mcp-adapter",
-  "version": "0.2.0",
+  "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",