@jalpp/mcp-adapter 0.2.0 → 0.3.1

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 and resources on an [MCP](https://modelcontextprotocol.io) server with full TypeScript type safety. Supports manual tool registration, automatic HTTP endpoint-to-tool bridging with built-in auth, path variables, method-specific adapters, and MCP resource registration.
 
 ## Installation
 
@@ -14,41 +14,203 @@ npm install @jalpp/mcp-adapter
 npm install @modelcontextprotocol/sdk zod axios
 ```
 
+---
+
 ## Adapters
 
+### Tool adapters
+
+| Adapter | Description |
+|---------|-------------|
+| `toolAdapter` | Registers a tool with a typed callback |
+| `toolContentAdapter` | Normalizes a result into a `CallToolResult` |
+| `httpToolAdapter` | Registers any HTTP endpoint as a tool |
+| `getToolAdapter` | Registers a GET endpoint as a tool — args → query params |
+| `postToolAdapter` | Registers a POST endpoint as a tool — args → request body |
+| `putToolAdapter` | Registers a PUT endpoint as a tool — args → request body |
+| `patchToolAdapter` | Registers a PATCH endpoint as a tool — args → request body |
+| `deleteToolAdapter` | Registers a DELETE endpoint as a tool — args → query params |
+
+### Resource 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 |
+| `staticResourceAdapter` | Registers a static MCP resource with a fixed URI |
+| `dynamicResourceAdapter` | Registers a dynamic MCP resource with a URI template |
+
+---
+
+## Path Variables
+
+All HTTP tool 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-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("Optional fields to expand"),
+  },
+  auth: { type: "bearer", token: process.env.API_TOKEN! },
+});
+// Registers get-user tool which calls GET https://api.example.com/users/abc123?expand=profile
+```
+
+---
+
+## `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! },
+});
+// Registers get-user tool which calls 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! },
+});
+// Registers create-post tool which calls 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
+import { putToolAdapter } from "@jalpp/mcp-adapter";
+
+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! },
+});
+// Registers update-user tool which calls 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
+import { patchToolAdapter } from "@jalpp/mcp-adapter";
+
+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! },
+});
+// Registers update-post-title tool which calls 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
+import { deleteToolAdapter } from "@jalpp/mcp-adapter";
+
+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! },
+});
+// Registers delete-post tool which calls DELETE https://api.example.com/posts/xyz789
+```
+
+---
+
+## `httpToolAdapter`
+
+Lower-level adapter that accepts an explicit `method` field. Use this when you prefer a single unified call style or need to pass the method dynamically.
+
+```ts
+import { httpToolAdapter } from "@jalpp/mcp-adapter";
+
+httpToolAdapter(server, {
+  name: "search-products",
+  description: "Search the product catalogue",
+  endpoint: "https://api.example.com/products/search",
+  method: "POST",
+  inputSchema: { query: z.string(), limit: z.number().optional() },
+  auth: { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! },
+});
+// Registers search-products tool which calls POST https://api.example.com/products/search  { query, limit }
+```
 
 ---
 
 ## `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",
+  name: "summarize-report",
   config: {
-    description: "Analyze a chess position",
+    description: "Fetch and summarize a sales report",
     inputSchema: {
-      fen: z.string().describe("FEN string"),
-      depth: z.number().min(1).max(20),
+      reportId: z.string().describe("Report ID"),
+      format: z.enum(["short", "detailed"]).default("short"),
     },
-    annotations: { openWorldHint: true },
   },
-  cb: async ({ fen, depth }) => {
-    const { data, error } = await myService.analyze(fen, depth);
+  cb: async ({ reportId, format }) => {
+    const { data, error } = await reportService.get(reportId, format);
     return toolContentAdapter(data ?? {}, error);
   },
 });
@@ -58,12 +220,10 @@ toolAdapter(server, {
 
 ```ts
 toolAdapter(server, {
-  name: "get-status",
-  config: {
-    description: "Returns current server status",
-  },
+  name: "get-server-status",
+  config: { description: "Returns current server status" },
   cb: async () => {
-    const { data, error } = await myService.getStatus();
+    const { data, error } = await statusService.get();
     return toolContentAdapter(data ?? {}, error);
   },
 });
@@ -76,105 +236,117 @@ toolAdapter(server, {
 Normalizes a service 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`
+## `staticResourceAdapter`
 
-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:**
+Registers a static MCP resource with a fixed URI. The `load` callback is called on every client request and may return fresh content each time. Use this for resources whose identity is fixed but content may change (e.g. a config file, a status page, a knowledge base).
 
 ```ts
-import { httpToolAdapter } from "@jalpp/mcp-adapter";
-import z from "zod";
+import { staticResourceAdapter } from "@jalpp/mcp-adapter";
+
+// Expose a live system health report
+staticResourceAdapter(server, {
+  name: "system-health",
+  uri: "status://health",
+  title: "System Health",
+  description: "Live health status of all services",
+  mimeType: "application/json",
+  load: async () => JSON.stringify(await healthService.getReport()),
+});
 
-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!,
-  },
+// Expose a markdown documentation page
+staticResourceAdapter(server, {
+  name: "api-docs",
+  uri: "docs://api",
+  title: "API Documentation",
+  description: "REST API reference documentation",
+  mimeType: "text/markdown",
+  load: () => fs.readFileSync("./docs/api.md", "utf-8"),
 });
 ```
 
-**Without input schema:**
+---
+
+## `dynamicResourceAdapter`
+
+Registers a dynamic MCP resource with a URI template. Use `{paramName}` placeholders — matched values are extracted and passed to the `load` callback. Use this for resources identified by an ID or other variable.
 
 ```ts
-httpToolAdapter(server, {
-  name: "get-server-status",
-  description: "Fetch API health status",
-  endpoint: "https://api.example.com/status",
-  method: "GET",
+import { dynamicResourceAdapter } from "@jalpp/mcp-adapter";
+
+// Expose a user profile by ID
+dynamicResourceAdapter(server, {
+  name: "user-profile",
+  uriTemplate: "users://{userId}/profile",
+  title: "User Profile",
+  description: "Profile data for a specific user",
+  mimeType: "application/json",
+  load: async (uri, { userId }) => JSON.stringify(await userService.getProfile(userId)),
+});
+
+// Expose an order invoice by order ID
+dynamicResourceAdapter(server, {
+  name: "order-invoice",
+  uriTemplate: "orders://{orderId}/invoice",
+  title: "Order Invoice",
+  description: "Invoice details for a specific order",
+  mimeType: "application/json",
+  load: async (uri, { orderId }) => JSON.stringify(await orderService.getInvoice(orderId)),
+});
+
+// Expose a blog post by slug
+dynamicResourceAdapter(server, {
+  name: "blog-post",
+  uriTemplate: "blog://{slug}",
+  title: "Blog Post",
+  description: "Markdown content for a blog post",
+  mimeType: "text/markdown",
+  load: async (uri, { slug }) => await blogService.getPostMarkdown(slug),
 });
 ```
 
-### Authentication
+---
 
-Three auth strategies are supported, all passed via the `auth` field:
+## Authentication
 
-**Bearer token** — sends `Authorization: Bearer <token>`:
+All HTTP tool adapters accept an optional `auth` field. Three strategies are supported:
 
+**Bearer token** — `Authorization: Bearer <token>`:
 ```ts
-auth: {
-  type: "bearer",
-  token: process.env.API_TOKEN!,
-}
+auth: { type: "bearer", token: process.env.API_TOKEN! }
 ```
 
-**API key** — sends the key in a custom header:
-
+**API key** — custom header:
 ```ts
-auth: {
-  type: "apikey",
-  header: "X-API-Key",
-  key: process.env.API_KEY!,
-}
+auth: { type: "apikey", header: "X-API-Key", key: process.env.API_KEY! }
 ```
 
-**Basic auth** — sends `Authorization: Basic <base64(username:password)>`:
-
+**Basic auth** — `Authorization: Basic <base64>`:
 ```ts
-auth: {
-  type: "basic",
-  username: "myuser",
-  password: process.env.PASSWORD!,
-}
+auth: { type: "basic", username: "user", 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 +354,26 @@ 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 |
+### Tool adapters
 
-### `toolContentAdapter(data, error)`
+| Function | Registers | Args mapping |
+|----------|-----------|--------------|
+| `getToolAdapter` | GET tool | remaining args → query params |
+| `postToolAdapter` | POST tool | remaining args → request body |
+| `putToolAdapter` | PUT tool | remaining args → request body |
+| `patchToolAdapter` | PATCH tool | remaining args → request body |
+| `deleteToolAdapter` | DELETE tool | remaining args → query params |
+| `httpToolAdapter` | any method tool | depends on method |
+| `toolAdapter` | custom callback tool | fully custom |
 
-Returns a `CallToolResult` with a single `text` content block.
+All HTTP adapters support optional `inputSchema` and `:paramName` path variables.
 
-### `httpToolAdapter(server, adapter)`
+### Resource adapters
 
-| Overload | When to use |
-|----------|-------------|
-| `httpToolAdapter<T>(server, HttpToolAdapterWithSchema<T>)` | Endpoint that receives typed input args |
-| `httpToolAdapter(server, HttpToolAdapterWithoutSchema)` | Endpoint that takes no input |
+| Function | Registers | URI style |
+|----------|-----------|-----------|
+| `staticResourceAdapter` | fixed-URI resource | `"scheme://path"` |
+| `dynamicResourceAdapter` | templated resource | `"scheme://{param}/path"` |
 
 ### 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,334 @@ 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.
  *
- * GET requests map input args to query parameters.
- * All other methods map input args to the JSON request body.
+ * 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 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;
+
+/**
+ * Supported MIME types for resource content.
+ * Extend with additional types as needed.
+ */
+type ResourceMimeType = "text/plain" | "text/html" | "text/markdown" | "application/json" | "application/xml" | (string & {});
+/**
+ * Configuration for registering a static MCP resource.
+ *
+ * A static resource has a fixed URI with no variable parameters.
+ * Use this for resources whose content may change but whose identity does not
+ * (e.g. a config file, a status page, a knowledge base).
+ *
+ * @example
+ * staticResourceAdapter(server, {
+ *   name: "server-config",
+ *   uri: "config://server",
+ *   title: "Server Configuration",
+ *   description: "Current server configuration and environment settings",
+ *   mimeType: "application/json",
+ *   load: async () => JSON.stringify(await configService.get()),
+ * });
+ */
+interface StaticResourceConfig {
+    /** Unique resource name used to identify the resource in the MCP registry. */
+    name: string;
+    /**
+     * The fixed URI that clients use to request this resource.
+     * @example "config://server"
+     * @example "docs://readme"
+     */
+    uri: string;
+    /** Human-readable display title shown in client UIs. */
+    title: string;
+    /** Description of what the resource contains, shown to the model. */
+    description: string;
+    /** MIME type of the resource content. Defaults to `"text/plain"`. */
+    mimeType?: ResourceMimeType;
+    /**
+     * Async function that returns the resource content as a string.
+     * Called each time a client requests the resource.
+     *
+     * @returns The resource content string.
+     *
+     * @example
+     * load: async () => JSON.stringify(await configService.get())
+     */
+    load: () => Promise<string> | string;
+}
+/**
+ * Configuration for registering a dynamic MCP resource with URI template parameters.
+ *
+ * A dynamic resource uses a URI template with `{paramName}` placeholders.
+ * The matched parameter values are passed to the `load` callback.
+ * Use this for resources identified by an ID or other variable (e.g. a user profile, an order record).
+ *
+ * @example
+ * dynamicResourceAdapter(server, {
+ *   name: "user-profile",
+ *   uriTemplate: "users://{userId}/profile",
+ *   title: "User Profile",
+ *   description: "Profile data for a given user",
+ *   mimeType: "application/json",
+ *   load: async (uri, { userId }) => JSON.stringify(await userService.getProfile(userId)),
+ * });
+ */
+interface DynamicResourceConfig {
+    /** Unique resource name used to identify the resource in the MCP registry. */
+    name: string;
+    /**
+     * URI template string with `{paramName}` placeholders.
+     * @example "users://{userId}/profile"
+     * @example "orders://{orderId}/invoice"
+     */
+    uriTemplate: string;
+    /** human-readable display title shown in client UIs. */
+    title: string;
+    /** Description of what the resource contains, shown to the model. */
+    description: string;
+    /** MIME type of the resource content. Defaults to `"text/plain"`. */
+    mimeType?: ResourceMimeType;
+    /**
+     * Async function that returns the resource content as a string.
+     * Called each time a client requests the resource with a matching URI.
+     *
+     * @param uri    - The full resolved URI of the request (as a `URL` object).
+     * @param params - Key-value map of extracted URI template parameters.
+     * @returns The resource content string.
+     *
+     * @example
+     * load: async (uri, { orderId }) => JSON.stringify(await orderService.getInvoice(orderId))
+     */
+    load: (uri: URL, params: Record<string, string>) => Promise<string> | string;
+}
+/**
+ * Registers a static MCP resource on an `McpServer`.
+ *
+ * Static resources have a fixed URI. The `load` callback is invoked on every
+ * client request and may return fresh data each time.
+ *
+ * @param server - The `McpServer` instance to register the resource on.
+ * @param config - Static resource configuration.
+ *
+ * @example
+ * // Expose a live system health report
+ * staticResourceAdapter(server, {
+ *   name: "system-health",
+ *   uri: "status://health",
+ *   title: "System Health",
+ *   description: "Live health status of all services",
+ *   mimeType: "application/json",
+ *   load: async () => JSON.stringify(await healthService.getReport()),
+ * });
+ *
+ * @example
+ * // Expose a static markdown documentation page
+ * staticResourceAdapter(server, {
+ *   name: "api-docs",
+ *   uri: "docs://api",
+ *   title: "API Documentation",
+ *   description: "REST API reference documentation",
+ *   mimeType: "text/markdown",
+ *   load: () => fs.readFileSync("./docs/api.md", "utf-8"),
+ * });
+ */
+declare function staticResourceAdapter(server: McpServer, config: StaticResourceConfig): void;
+/**
+ * Registers a dynamic MCP resource with a URI template on an `McpServer`.
+ *
+ * Dynamic resources use `{paramName}` placeholders in the URI template.
+ * Matched parameter values are extracted and passed to the `load` callback.
+ *
+ * @param server - The `McpServer` instance to register the resource on.
+ * @param config - Dynamic resource configuration.
+ *
+ * @example
+ * // Expose a user profile by ID
+ * dynamicResourceAdapter(server, {
+ *   name: "user-profile",
+ *   uriTemplate: "users://{userId}/profile",
+ *   title: "User Profile",
+ *   description: "Profile data for a specific user",
+ *   mimeType: "application/json",
+ *   load: async (uri, { userId }) => JSON.stringify(await userService.getProfile(userId)),
+ * });
+ *
+ * @example
+ * // Expose an order invoice by order ID
+ * dynamicResourceAdapter(server, {
+ *   name: "order-invoice",
+ *   uriTemplate: "orders://{orderId}/invoice",
+ *   title: "Order Invoice",
+ *   description: "Invoice details for a specific order",
+ *   mimeType: "application/json",
+ *   load: async (uri, { orderId }) => JSON.stringify(await orderService.getInvoice(orderId)),
+ * });
+ *
+ * @example
+ * // Expose a blog post by slug
+ * dynamicResourceAdapter(server, {
+ *   name: "blog-post",
+ *   uriTemplate: "blog://{slug}",
+ *   title: "Blog Post",
+ *   description: "Markdown content for a blog post",
+ *   mimeType: "text/markdown",
+ *   load: async (uri, { slug }) => await blogService.getPostMarkdown(slug),
+ * });
+ */
+declare function dynamicResourceAdapter(server: McpServer, config: DynamicResourceConfig): 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 DynamicResourceConfig, type GetToolAdapterConfig, type GetToolAdapterConfigNoSchema, type HttpAuth, type HttpMethod, type HttpToolAdapterWithSchema, type HttpToolAdapterWithoutSchema, type PatchToolAdapterConfig, type PostToolAdapterConfig, type PostToolAdapterConfigNoSchema, type PutToolAdapterConfig, type ResourceMimeType, type StaticResourceConfig, deleteToolAdapter, dynamicResourceAdapter, getToolAdapter, httpToolAdapter, patchToolAdapter, postToolAdapter, putToolAdapter, staticResourceAdapter, 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,73 @@ 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" });
+}
+
+// src/resourceAdapter.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function staticResourceAdapter(server, config) {
+  server.registerResource(
+    config.name,
+    config.uri,
+    {
+      title: config.title,
+      description: config.description,
+      mimeType: config.mimeType ?? "text/plain"
+    },
+    async (uri) => ({
+      contents: [
+        {
+          uri: uri.href,
+          text: await config.load(),
+          mimeType: config.mimeType ?? "text/plain"
+        }
+      ]
+    })
+  );
+}
+function dynamicResourceAdapter(server, config) {
+  server.registerResource(
+    config.name,
+    new ResourceTemplate(config.uriTemplate, { list: void 0 }),
+    {
+      title: config.title,
+      description: config.description,
+      mimeType: config.mimeType ?? "text/plain"
+    },
+    async (uri, params) => ({
+      contents: [
+        {
+          uri: uri.href,
+          text: await config.load(uri, params),
+          mimeType: config.mimeType ?? "text/plain"
+        }
+      ]
+    })
+  );
+}
 export {
+  deleteToolAdapter,
+  dynamicResourceAdapter,
+  getToolAdapter,
   httpToolAdapter,
+  patchToolAdapter,
+  postToolAdapter,
+  putToolAdapter,
+  staticResourceAdapter,
   toolAdapter,
   toolContentAdapter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jalpp/mcp-adapter",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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",
@@ -44,17 +44,17 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.0.0",
-    "zod": ">=3.0.0",
-    "axios": ">=1.0.0"
+    "axios": ">=1.0.0",
+    "zod": ">=3.0.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": ">=1.0.0",
-    "@types/node": "^20.0.0",
+    "@types/node": "^25.4.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0",
     "zod": ">=3.0.0"
   },
   "dependencies": {
-    "axios": "^1.13.6"
+    "axios": ">=1.0.0"
   }
 }