@vibetools/dokploy-mcp 0.5.0 → 1.2.0

package/README.md

@@ -4,7 +4,9 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Node >= 22](https://img.shields.io/badge/node-%3E%3D22-brightgreen)](https://nodejs.org/)
 
-MCP server for the Dokploy API. 196 tools across 23 modules. Your AI agent can now deploy apps, manage databases, configure domains, and handle backups -- without you touching a dashboard.
+MCP server for the Dokploy API. 377 tools across 35 modules. Your AI agent can now deploy apps, manage databases, configure domains, and handle backups -- without you touching a dashboard.
+
+Forked from [Dokploy/mcp](https://github.com/Dokploy/mcp) and rebuilt with expanded API coverage, tool annotations, Zod v4 schemas, lazy config loading, and a setup wizard. The original had 67 tools. This one has 377. Standing on shoulders, etc.
 
 ## Quick Start
 
@@ -43,7 +45,7 @@ If you already have the [Dokploy CLI](https://github.com/Dokploy/cli) installed
 
 ## Features
 
-- **196 tools, 23 modules** -- applications, compose, databases (Postgres/MySQL/MariaDB/MongoDB/Redis), domains, backups, Docker, settings, and more
+- **377 tools, 35 modules** -- applications, compose, environments, servers, Git providers, notifications, databases (Postgres/MySQL/MariaDB/MongoDB/Redis), domains, backups, deployment queues, rollback, patching, Docker, settings, preview deployments, schedules, and more
 - **Tool annotations** -- `readOnlyHint`, `destructiveHint`, `idempotentHint` so clients can warn before you nuke something
 - **Type-safe schemas** -- Zod v4 validation on every parameter
 - **Lazy config loading** -- validates credentials on first API call, not at startup
@@ -134,18 +136,24 @@ Already ran `setup` or have Dokploy CLI authenticated? Drop the `env` block enti
 
 | Module | Tools | Module | Tools |
 |--------|-------|--------|-------|
-| Project | 6 | Deployment | 2 |
-| Application | 26 | Docker | 4 |
-| Compose | 14 | Certificates | 4 |
-| Domain | 8 | Registry | 6 |
-| PostgreSQL | 13 | Destination | 6 |
-| MySQL | 13 | Backup | 8 |
-| MariaDB | 13 | Mounts | 4 |
-| MongoDB | 13 | Port | 4 |
-| Redis | 13 | Redirects | 4 |
+| Project | 8 | Deployment | 8 |
+| Environment | 7 | Docker | 7 |
+| Application | 29 | Server | 16 |
+| Compose | 28 | Certificates | 4 |
+| Domain | 9 | Registry | 6 |
+| Patch | 12 | SSH Key | 6 |
+| Git Provider | 2 | GitHub | 6 |
+| GitLab | 7 | PostgreSQL | 14 |
+| Notification | 38 | MySQL | 14 |
+| Destination | 6 | MariaDB | 14 |
+| Backup | 11 | MongoDB | 14 |
+| Mounts | 6 | Redis | 14 |
+| Port | 4 | Volume Backups | 6 |
+| Redirects | 4 | Rollback | 2 |
+| Preview Deployment | 4 | Schedule | 6 |
 | Security | 4 | Cluster | 4 |
-| Settings | 25 | Admin | 1 |
-| User | 1 | | |
+| Settings | 49 | Admin | 1 |
+| User | 7 | | |
 
 Full reference with parameters and descriptions: **[docs/tools.md](docs/tools.md)**
 
@@ -207,6 +215,24 @@ Test with the MCP Inspector:
 npx @modelcontextprotocol/inspector node dist/index.js
 ```
 
+## Standing on the Shoulders of People Who Actually Did the Work
+
+This project is a fork of [Dokploy/mcp](https://github.com/Dokploy/mcp). I rewrote most of it, tripled the tool count, and added things like a setup wizard and config resolution chain -- but "rewrote" is easy when someone else already built the thing you're rewriting.
+
+[Mauricio Siu](https://github.com/Siumauricio) created [Dokploy](https://dokploy.com) itself -- a genuinely impressive open-source PaaS -- and kicked off the MCP server repo. Without Dokploy, there's no API. Without the API, there's no MCP server. Without the MCP server, I'd have had to start from zero instead of "from scratch."
+
+[Henrique Andrade](https://github.com/andradehenrique) did the actual heavy lifting on the original MCP. Projects, applications, PostgreSQL, MySQL, domains -- that was all him. 15 commits, every merged PR. The kind of contributor who doesn't just open issues, he closes them.
+
+And to everyone who opened PRs on the original repo -- merged or not -- your code and ideas shaped what this became:
+
+[Joshua Macauley](https://github.com/Macawls) · [lucasleal-developer](https://github.com/lucasleal-developer) · [Nour Eddine Hamaidi](https://github.com/HenkDz) · [Corey](https://github.com/limehawk) · [Azil0ne](https://github.com/Azilone)
+
+Unmerged PRs are still blueprints. Someone reads your compose tools PR and thinks "right, I should cover that." Someone sees your consolidation approach and borrows the idea. That's how open source actually works -- not through clean merge histories, but through stolen inspiration with better commit messages.
+
+Cheers to all of you. I owe you mass-produced coffee at minimum.
+
 ## License
 
 MIT - [Vibe Code](https://vcode.sh)
+
+Original work by [Henrique Andrade](https://github.com/andradehenrique) under Apache 2.0 -- see [LICENSE-ORIGINAL](LICENSE-ORIGINAL).

package/dist/api/client.d.ts

@@ -1,3 +1,4 @@
+export declare function unwrapTrpcResponse(data: unknown): unknown;
 export declare class ApiError extends Error {
     readonly status: number;
     readonly statusText: string;
@@ -5,6 +6,7 @@ export declare class ApiError extends Error {
     readonly endpoint: string;
     constructor(status: number, statusText: string, body: unknown, endpoint: string);
 }
+export declare function buildQueryString(body: unknown): string;
 export declare const api: {
     get: <T = unknown>(path: string, params?: Record<string, unknown>) => Promise<T>;
     post: <T = unknown>(path: string, body?: unknown) => Promise<T>;

package/dist/api/client.js

@@ -1,4 +1,38 @@
 import { resolveConfig } from '../config/resolver.js';
+const DEFAULT_TIMEOUT = 30_000;
+function getErrorMessage(body, statusText) {
+    if (typeof body !== 'object' || body === null) {
+        return statusText;
+    }
+    if ('message' in body && typeof body.message === 'string') {
+        return body.message;
+    }
+    if ('error' in body && typeof body.error === 'object' && body.error !== null) {
+        const error = body.error;
+        if ('message' in error && typeof error.message === 'string') {
+            return error.message;
+        }
+        if ('json' in error && typeof error.json === 'object' && error.json !== null) {
+            const json = error.json;
+            if ('message' in json && typeof json.message === 'string') {
+                return json.message;
+            }
+        }
+    }
+    return statusText;
+}
+export function unwrapTrpcResponse(data) {
+    if (typeof data !== 'object' || data === null)
+        return data;
+    const outer = data;
+    if (typeof outer.result !== 'object' || outer.result === null)
+        return data;
+    const result = outer.result;
+    if (typeof result.data !== 'object' || result.data === null)
+        return data;
+    const inner = result.data;
+    return 'json' in inner ? inner.json : data;
+}
 function getConfig() {
     const resolved = resolveConfig();
     if (!resolved) {
@@ -14,7 +48,7 @@ function getConfig() {
     return {
         baseUrl: resolved.url.replace(/\/+$/, ''),
         apiKey: resolved.apiKey,
-        timeout: resolved.timeout,
+        timeout: resolved.timeout || DEFAULT_TIMEOUT,
     };
 }
 let _config = null;
@@ -28,9 +62,7 @@ export class ApiError extends Error {
     body;
     endpoint;
     constructor(status, statusText, body, endpoint) {
-        const msg = typeof body === 'object' && body !== null && 'message' in body
-            ? body.message
-            : statusText;
+        const msg = getErrorMessage(body, statusText);
         super(`Dokploy API error (${status}): ${msg}`);
         this.status = status;
         this.statusText = statusText;
@@ -39,18 +71,21 @@ export class ApiError extends Error {
         this.name = 'ApiError';
     }
 }
-function buildQueryString(body) {
-    if (!body || typeof body !== 'object') {
+export function buildQueryString(body) {
+    if (body == null)
         return '';
-    }
-    const params = new URLSearchParams();
-    for (const [k, v] of Object.entries(body)) {
-        if (v !== undefined && v !== null) {
-            params.set(k, String(v));
-        }
-    }
-    return params.toString();
+    if (typeof body !== 'object')
+        return '';
+    const params = Object.fromEntries(Object.entries(body).filter(([, value]) => value != null));
+    return new URLSearchParams({
+        input: JSON.stringify({ json: params }),
+    }).toString();
 }
+/**
+ * Checks whether an error was caused by an aborted fetch.
+ * Both checks are needed: older Node versions throw DOMException,
+ * while newer versions throw an Error with name 'AbortError'.
+ */
 function isAbortError(error) {
     return error instanceof DOMException || (error instanceof Error && error.name === 'AbortError');
 }
@@ -68,7 +103,7 @@ async function request(method, path, body) {
                 Accept: 'application/json',
                 'x-api-key': apiKey,
             },
-            body: method === 'POST' && body ? JSON.stringify(body) : undefined,
+            body: method === 'POST' && body ? JSON.stringify({ json: body }) : undefined,
             signal: controller.signal,
         });
         const text = await response.text();
@@ -82,7 +117,7 @@ async function request(method, path, body) {
         if (!response.ok) {
             throw new ApiError(response.status, response.statusText, data, path);
         }
-        return data;
+        return unwrapTrpcResponse(data);
     }
     catch (error) {
         if (error instanceof ApiError) {

package/dist/config/resolver.js

@@ -1,7 +1,28 @@
 import { execSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { z } from 'zod';
 import { getConfigDir, getConfigFilePath } from './types.js';
+const configFileSchema = z.object({
+    url: z.string().min(1),
+    apiKey: z.string().min(1),
+});
+const dokployCliSchema = z.object({
+    url: z.string().min(1),
+    token: z.string().min(1),
+});
+const userSchema = z
+    .object({
+    email: z.string().optional(),
+    user: z
+        .object({
+        email: z.string().optional(),
+        firstName: z.string().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const versionSchema = z.union([z.string(), z.object({ version: z.string() }).passthrough()]);
 /**
  * Normalizes a Dokploy URL to the tRPC API base.
  * Accepts any of these formats:
@@ -74,20 +95,8 @@ function readConfigFile() {
     try {
         const content = readFileSync(filePath, 'utf8');
         const parsed = JSON.parse(content);
-        if (typeof parsed !== 'object' ||
-            parsed === null ||
-            !('url' in parsed) ||
-            !('apiKey' in parsed)) {
-            return null;
-        }
-        const record = parsed;
-        if (typeof record.url !== 'string' || typeof record.apiKey !== 'string') {
-            return null;
-        }
-        if (!(record.url && record.apiKey)) {
-            return null;
-        }
-        return { url: record.url, apiKey: record.apiKey };
+        const result = configFileSchema.safeParse(parsed);
+        return result.success ? result.data : null;
     }
     catch {
         return null;
@@ -107,20 +116,8 @@ function readDokployCliConfig() {
         }
         const content = readFileSync(cliConfigPath, 'utf8');
         const parsed = JSON.parse(content);
-        if (typeof parsed !== 'object' ||
-            parsed === null ||
-            !('url' in parsed) ||
-            !('token' in parsed)) {
-            return null;
-        }
-        const record = parsed;
-        if (typeof record.url !== 'string' || typeof record.token !== 'string') {
-            return null;
-        }
-        if (!(record.url && record.token)) {
-            return null;
-        }
-        return { url: record.url, apiKey: record.token };
+        const result = dokployCliSchema.safeParse(parsed);
+        return result.success ? { url: result.data.url, apiKey: result.data.token } : null;
     }
     catch {
         return null;
@@ -212,21 +209,11 @@ function unwrapTrpc(data) {
 }
 function parseUser(data) {
     const unwrapped = unwrapTrpc(data);
-    if (typeof unwrapped !== 'object' || unwrapped === null)
+    const result = userSchema.safeParse(unwrapped);
+    if (!result.success)
         return undefined;
-    const record = unwrapped;
-    // Top-level email/name
-    if (typeof record.email === 'string')
-        return record.email;
-    // Nested user object (tRPC user.get response)
-    if (typeof record.user === 'object' && record.user !== null) {
-        const user = record.user;
-        if (typeof user.email === 'string')
-            return user.email;
-        if (typeof user.firstName === 'string')
-            return user.firstName;
-    }
-    return undefined;
+    const { email, user } = result.data;
+    return email ?? user?.email ?? user?.firstName;
 }
 async function fetchVersion(baseUrl, apiKey) {
     const controller = new AbortController();
@@ -241,14 +228,10 @@ async function fetchVersion(baseUrl, apiKey) {
             return undefined;
         const data = await response.json();
         const unwrapped = unwrapTrpc(data);
-        if (typeof unwrapped === 'string')
-            return unwrapped;
-        if (typeof unwrapped === 'object' && unwrapped !== null) {
-            const record = unwrapped;
-            if (typeof record.version === 'string')
-                return record.version;
-        }
-        return undefined;
+        const result = versionSchema.safeParse(unwrapped);
+        if (!result.success)
+            return undefined;
+        return typeof result.data === 'string' ? result.data : result.data.version;
     }
     catch {
         return undefined;

package/dist/server.js

@@ -3,7 +3,7 @@ import { allTools } from './tools/index.js';
 export function createServer() {
     const server = new McpServer({
         name: 'dokploy-mcp-server',
-        version: '0.1.0',
+        version: '1.0.0',
     });
     for (const tool of allTools) {
         server.registerTool(tool.name, {

package/dist/tools/_database.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { type ToolDefinition } from './_factory.js';
+type AnyZodObject = z.ZodObject;
+export interface DatabaseConfig {
+    type: string;
+    idField: string;
+    displayName: string;
+    defaultImage: string;
+    createFields: AnyZodObject;
+}
+export declare function createDatabaseTools(config: DatabaseConfig): ToolDefinition[];
+export {};

package/dist/tools/_database.js

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+export function createDatabaseTools(config) {
+    const { type, idField, displayName, defaultImage, createFields } = config;
+    const idSchema = z
+        .object({ [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`) })
+        .strict();
+    function tool(action, title, description, schema, opts = {}) {
+        const endpoint = `/${type}.${action}`;
+        const name = `dokploy_${type}_${action.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`)}`;
+        if (opts.get) {
+            return getTool({ name, title, description, schema, endpoint, annotations: opts.annotations });
+        }
+        return postTool({ name, title, description, schema, endpoint, annotations: opts.annotations });
+    }
+    const one = tool('one', `Get ${displayName} Details`, `Retrieve detailed information about a specific ${displayName} database managed by Dokploy. Returns the full configuration including connection settings, resource limits, environment variables, and current status. Requires the unique ${displayName} database ID.`, idSchema, { get: true });
+    const create = tool('create', `Create ${displayName} Database`, `Create a new ${displayName} database instance inside a Dokploy environment. Requires a display name and the target environment ID. Optionally specify an app-level identifier, Docker image, description, or remote server. Returns the newly created database record.`, z
+        .object({
+        name: z.string().min(1).describe('Display name for the database'),
+        appName: z
+            .string()
+            .min(1)
+            .max(63)
+            .regex(/^[a-zA-Z0-9._-]+$/)
+            .optional()
+            .describe('Unique app-level identifier'),
+        ...createFields.shape,
+        environmentId: z.string().min(1).describe('Environment ID to create the database in'),
+        dockerImage: z.string().optional().describe(`Docker image (default: ${defaultImage})`),
+        description: z.string().nullable().optional().describe('Optional description'),
+        serverId: z.string().nullable().optional().describe('Target server ID (null for local)'),
+    })
+        .strict());
+    const update = tool('update', `Update ${displayName} Database`, `Update the configuration of an existing ${displayName} database in Dokploy. Supports modifying the display name, Docker image, resource limits (CPU and memory), custom start command, environment variables, and external port. Requires the ${displayName} database ID. Only the provided fields are updated.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        name: z.string().min(1).optional().describe('Display name'),
+        appName: z.string().min(1).optional().describe('App-level identifier'),
+        description: z.string().nullable().optional().describe('Description'),
+        dockerImage: z.string().optional().describe('Docker image'),
+        memoryReservation: z.number().nullable().optional().describe('Memory reservation in MB'),
+        memoryLimit: z.number().nullable().optional().describe('Memory limit in MB'),
+        cpuReservation: z.number().nullable().optional().describe('CPU reservation'),
+        cpuLimit: z.number().nullable().optional().describe('CPU limit'),
+        command: z.string().nullable().optional().describe('Custom start command'),
+        env: z.string().nullable().optional().describe('Environment variables'),
+        externalPort: z.number().nullable().optional().describe('External port'),
+    })
+        .strict());
+    const remove = tool('remove', `Remove ${displayName} Database`, `Permanently delete a ${displayName} database from Dokploy. This action removes the database container, its data, and all associated configuration. Requires the ${displayName} database ID. This operation is destructive and cannot be undone.`, idSchema, { annotations: { destructiveHint: true } });
+    const move = tool('move', `Move ${displayName} Database`, `Move a ${displayName} database from its current environment to a different environment within Dokploy. Requires the ${displayName} database ID and the destination environment ID. The database configuration and data are preserved during the move.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        targetEnvironmentId: z.string().min(1).describe('Destination environment ID'),
+    })
+        .strict());
+    const deploy = tool('deploy', `Deploy ${displayName} Database`, `Deploy a ${displayName} database container in Dokploy. Triggers the build and start process for the specified database. Requires the ${displayName} database ID. Returns the deployment status.`, idSchema);
+    const start = tool('start', `Start ${displayName} Database`, `Start a previously stopped ${displayName} database container in Dokploy. The database must already be deployed. Requires the ${displayName} database ID. Returns the updated status after starting.`, idSchema);
+    const stop = tool('stop', `Stop ${displayName} Database`, `Stop a running ${displayName} database container in Dokploy. The database data is preserved but the container will no longer accept connections. Requires the ${displayName} database ID. This is a destructive action as it interrupts active connections.`, idSchema, { annotations: { destructiveHint: true } });
+    const reload = tool('reload', `Reload ${displayName} Database`, `Reload the ${displayName} database container in Dokploy without a full restart. Applies configuration changes that do not require a rebuild. Requires the ${displayName} database ID and the app-level identifier. Returns the reload status.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        appName: z.string().min(1).describe('App-level identifier'),
+    })
+        .strict());
+    const rebuild = tool('rebuild', `Rebuild ${displayName} Database`, `Rebuild the ${displayName} database container from scratch in Dokploy. This tears down the existing container and recreates it with the current configuration. Requires the ${displayName} database ID. Useful after changing the Docker image or when the container is in a broken state.`, idSchema);
+    const changeStatus = tool('changeStatus', `Change ${displayName} Status`, `Manually set the application status of a ${displayName} database in Dokploy. Accepts one of: idle, running, done, or error. Requires the ${displayName} database ID and the new status value. Useful for correcting a stale or incorrect status.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        applicationStatus: z
+            .enum(['idle', 'running', 'done', 'error'])
+            .describe('New application status'),
+    })
+        .strict());
+    const saveExternalPort = tool('saveExternalPort', `Save ${displayName} External Port`, `Set or clear the external port mapping for a ${displayName} database in Dokploy. When set, the database is accessible from outside the Docker network on the specified port. Pass null to remove the external port. Requires the ${displayName} database ID.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        externalPort: z.number().nullable().describe('External port number (null to remove)'),
+    })
+        .strict());
+    const saveEnvironment = tool('saveEnvironment', `Save ${displayName} Environment`, `Overwrite the environment variables for a ${displayName} database in Dokploy. Replaces all existing environment variables with the provided value. Pass the variables as a single string (one per line, KEY=VALUE format). Requires the ${displayName} database ID.`, z
+        .object({
+        [idField]: z.string().min(1).describe(`Unique ${displayName} database ID`),
+        env: z.string().nullable().optional().describe('Environment variables as a string'),
+    })
+        .strict());
+    const search = tool('search', `Search ${displayName} Databases`, `Search ${displayName} databases in Dokploy by free text or field-specific filters. Supports pagination through limit and offset.`, z
+        .object({
+        q: z.string().optional().describe('Free-text query'),
+        name: z.string().optional().describe('Display name'),
+        appName: z.string().optional().describe('App-level identifier'),
+        description: z.string().optional().describe('Description'),
+        projectId: z.string().optional().describe('Project ID'),
+        environmentId: z.string().optional().describe('Environment ID'),
+        limit: z.number().min(1).max(100).optional().describe('Maximum number of results'),
+        offset: z.number().min(0).optional().describe('Number of results to skip'),
+    })
+        .strict(), { get: true });
+    return [
+        one,
+        create,
+        update,
+        remove,
+        move,
+        deploy,
+        start,
+        stop,
+        reload,
+        rebuild,
+        changeStatus,
+        saveExternalPort,
+        saveEnvironment,
+        search,
+    ];
+}

package/dist/tools/_factory.d.ts

@@ -12,6 +12,8 @@ export interface ToolDefinition {
     name: string;
     title: string;
     description: string;
+    endpoint?: string;
+    method?: 'GET' | 'POST';
     schema: AnyZodObject;
     annotations: ToolAnnotations;
     handler: (input: Record<string, unknown>) => Promise<{
@@ -28,7 +30,7 @@ export declare function createTool<T extends AnyZodObject>(def: {
     title: string;
     description: string;
     schema: T;
-    annotations: ToolAnnotations;
+    annotations?: Partial<ToolAnnotations>;
     handler: (params: {
         input: z.infer<T>;
         api: typeof api;

package/dist/tools/_factory.js

@@ -1,8 +1,15 @@
 import { ApiError, api } from '../api/client.js';
+function wrapStructured(data) {
+    if (Array.isArray(data))
+        return { items: data };
+    if (data === null || data === undefined || typeof data !== 'object')
+        return { value: data };
+    return data;
+}
 function success(data) {
     return {
         content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        structuredContent: data,
+        structuredContent: wrapStructured(data),
     };
 }
 function error(message, details) {
@@ -16,19 +23,22 @@ function error(message, details) {
         isError: true,
     };
 }
+const ERROR_MAP = {
+    401: ['Authentication failed', () => 'Check your DOKPLOY_API_KEY environment variable.'],
+    403: ['Permission denied', () => 'Your API key lacks permission for this operation.'],
+    404: ['Resource not found', (err) => err.message],
+    422: [
+        'Validation error',
+        (err) => typeof err.body === 'object' && err.body !== null ? JSON.stringify(err.body) : err.message,
+    ],
+};
 function mapApiError(err) {
-    switch (err.status) {
-        case 401:
-            return error('Authentication failed', 'Check your DOKPLOY_API_KEY environment variable.');
-        case 403:
-            return error('Permission denied', 'Your API key lacks permission for this operation.');
-        case 404:
-            return error('Resource not found', err.message);
-        case 422:
-            return error('Validation error', typeof err.body === 'object' && err.body !== null ? JSON.stringify(err.body) : err.message);
-        default:
-            return error(`Dokploy API error (${err.status})`, err.message);
+    const entry = ERROR_MAP[err.status];
+    if (entry) {
+        const [message, getDetails] = entry;
+        return error(message, getDetails(err));
     }
+    return error(`Dokploy API error (${err.status})`, err.message);
 }
 export function createTool(def) {
     return {
@@ -52,17 +62,22 @@ export function createTool(def) {
     };
 }
 export function postTool(opts) {
-    return createTool({
+    const tool = createTool({
         name: opts.name,
         title: opts.title,
         description: opts.description,
         schema: opts.schema,
-        annotations: { openWorldHint: true, ...opts.annotations },
+        annotations: opts.annotations,
         handler: async ({ input, api }) => api.post(opts.endpoint, input),
     });
+    return {
+        ...tool,
+        endpoint: opts.endpoint,
+        method: 'POST',
+    };
 }
 export function getTool(opts) {
-    return createTool({
+    const tool = createTool({
         name: opts.name,
         title: opts.title,
         description: opts.description,
@@ -70,7 +85,6 @@ export function getTool(opts) {
         annotations: {
             readOnlyHint: true,
             idempotentHint: true,
-            openWorldHint: true,
             ...opts.annotations,
         },
         handler: async ({ input, api }) => {
@@ -80,7 +94,12 @@ export function getTool(opts) {
                     params[k] = v;
                 }
             }
-            return api.get(opts.endpoint, Object.keys(params).length > 0 ? params : undefined);
+            return api.get(opts.endpoint, params);
         },
     });
+    return {
+        ...tool,
+        endpoint: opts.endpoint,
+        method: 'GET',
+    };
 }