@postman/postman-mcp-server 2.4.9 → 2.5.2

package/dist/src/tools/getCollectionMap.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { asMcpError, McpError } from './utils/toolHelpers.js';
+export const method = 'getCollectionMap';
+export const description = `Get a Postman collection map with metadata and a complete recursive index of all folders and requests. Response includes collection metadata and description. Response includes itemRefs property (name and id only) instead of the full item array. After calling, present the collection summary and ask the user where they\'d like to explore next, calling getCollectionFolder and/or getCollectionRequest tools in parallel to get more data quickly.
+  Once you've called this tool, DO NOT call searchPostmanElements to find items in or related to this collection. Instead, use the map in itemRefs.
+  Only use searchPostmanElements to find the collection where a request may be. Then, stay in the collection and don't use the search.
+  When using the getCollectionRequest tool to look up request data, omit the populate parameter to avoid getting all response examples
+  back at once (can be very large). Instead, use the response ids from the return value and call getCollectionResponse for each one.
+  Prepend the collection's ownerId to the front of each response id when passing it to getCollectionResponse. This is the first part of the collection uid.
+  Infer the response schema from that information and remember it. Omit the raw response examples from the conversation going forward.`;
+export const parameters = z.object({
+    collectionId: z
+        .string()
+        .describe('The collection ID must be in the form <OWNER_ID>-<UUID> (e.g. 12345-33823532ab9e41c9b6fd12d0fd459b8b).'),
+    access_key: z
+        .string()
+        .describe("A collection's read-only access key. Using this query parameter does not require an API key to call the endpoint.")
+        .optional(),
+});
+export const annotations = {
+    title: 'Get Postman Collection Map',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+};
+function buildItemRefs(items) {
+    if (!Array.isArray(items) || items.length === 0) {
+        return undefined;
+    }
+    return items.map((item) => {
+        const itemId = item.uid || item.id || '';
+        const itemRef = {
+            name: item.name || '',
+            id: itemId,
+        };
+        if (item.item && Array.isArray(item.item)) {
+            const nestedRefs = buildItemRefs(item.item);
+            if (nestedRefs) {
+                itemRef.itemRefs = nestedRefs;
+            }
+        }
+        return itemRef;
+    });
+}
+export async function handler(args, extra) {
+    try {
+        const endpoint = `/collections/${args.collectionId}`;
+        const query = new URLSearchParams();
+        if (args.access_key !== undefined)
+            query.set('access_key', String(args.access_key));
+        const url = query.toString() ? `${endpoint}?${query.toString()}` : endpoint;
+        const options = {
+            headers: extra.headers,
+        };
+        const result = await extra.client.get(url, options);
+        if (typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: result,
+                    },
+                ],
+            };
+        }
+        const response = result;
+        if (response.collection) {
+            const { item, ...collectionWithoutItems } = response.collection;
+            const itemRefs = buildItemRefs(item);
+            const processedResponse = {
+                ...response,
+                collection: {
+                    ...collectionWithoutItems,
+                    ...(itemRefs && { itemRefs }),
+                },
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(processedResponse, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (e) {
+        if (e instanceof McpError) {
+            throw e;
+        }
+        throw asMcpError(e);
+    }
+}

package/dist/src/tools/runCollection.js

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-import newman from 'newman';
-import { TestTracker, OutputBuilder, buildNewmanOptions } from './utils/runner.js';
 import { asMcpError, McpError } from './utils/toolHelpers.js';
+import { runCollection } from './runner/index.js';
 export const method = 'runCollection';
 export const description = 'Runs a Postman collection by ID with detailed test results and execution statistics. Supports optional environment for variable substitution. Note: Advanced parameters like custom delays and other runtime options are not yet available.';
 export const parameters = z.object({
@@ -37,85 +36,12 @@ export const annotations = {
 };
 export async function handler(params, extra) {
     try {
-        const tracker = new TestTracker();
-        const output = new OutputBuilder();
-        output.add(`🚀 Fetching collection with ID: ${params.collectionId}`);
-        const response = await extra.client.get(`/collections/${params.collectionId}`);
-        const collectionJSON = response.collection || response;
-        output.add(`✅ Successfully fetched collection: ${collectionJSON.info?.name || 'Unknown'}\n`);
-        let environmentJSON;
-        if (params.environmentId) {
-            output.add(`🌍 Fetching environment with ID: ${params.environmentId}`);
-            const envResponse = await extra.client.get(`/environments/${params.environmentId}`);
-            environmentJSON = envResponse.environment || envResponse;
-            output.add(`✅ Successfully fetched environment: ${environmentJSON.name || 'Unknown'}\n`);
-        }
-        const newmanOptions = buildNewmanOptions(params, collectionJSON, environmentJSON);
-        const startTime = Date.now();
-        await new Promise((resolve, reject) => {
-            newman
-                .run(newmanOptions)
-                .on('start', () => {
-                output.add('🎯 Starting collection run...\n');
-            })
-                .on('assertion', (_err, args) => {
-                if (args.assertion) {
-                    tracker.addAssertion({
-                        passed: !args.error,
-                        assertion: args.assertion,
-                        name: args.assertion,
-                        error: args.error,
-                    });
-                }
-            })
-                .on('item', (_err, args) => {
-                if (args.item) {
-                    const testResults = tracker.displayCurrentResults();
-                    if (testResults) {
-                        output.add(`\n📝 Request: ${args.item.name}`);
-                        output.add(testResults);
-                    }
-                }
-            })
-                .on('done', (err, summary) => {
-                const endTime = Date.now();
-                const durationMs = endTime - startTime;
-                const durationSec = (durationMs / 1000).toFixed(2);
-                if (err) {
-                    output.add('\n❌ Run error: ' + err.message);
-                    output.add(`⏱️  Duration: ${durationSec}s`);
-                    reject(err);
-                    return;
-                }
-                output.add('\n=== ✅ Run completed! ===');
-                output.add(`⏱️  Duration: ${durationSec}s`);
-                const testStats = tracker.getTotalStats();
-                if (testStats.total > 0) {
-                    output.add('\n📊 Overall Test Statistics:');
-                    output.add(`  Total tests: ${testStats.total}`);
-                    output.add(`  Passed: ${testStats.passed} ✅`);
-                    output.add(`  Failed: ${testStats.failed} ❌`);
-                    output.add(`  Success rate: ${((testStats.passed / testStats.total) * 100).toFixed(1)}%`);
-                }
-                if (summary?.run?.stats) {
-                    output.add('\n📈 Request Summary:');
-                    output.add(`  Total requests: ${summary.run.stats.requests?.total || 0}`);
-                    output.add(`  Failed requests: ${summary.run.stats.requests?.failed || 0}`);
-                    output.add(`  Total assertions: ${summary.run.stats.assertions?.total || 0}`);
-                    output.add(`  Failed assertions: ${summary.run.stats.assertions?.failed || 0}`);
-                    if (summary.run.stats.iterations) {
-                        output.add(`  Total iterations: ${summary.run.stats.iterations.total || 0}`);
-                        output.add(`  Failed iterations: ${summary.run.stats.iterations.failed || 0}`);
-                    }
-                }
-                resolve();
-            });
-        });
+        const output = await runCollection(params, extra.client);
         return {
             content: [
                 {
                     type: 'text',
-                    text: output.build(),
+                    text: output,
                 },
             ],
         };

package/dist/src/tools/runner/executor.js

@@ -0,0 +1,165 @@
+import newman from 'newman';
+export class OutputBuilder {
+    lines = [];
+    add(line) {
+        this.lines.push(line);
+    }
+    build() {
+        return this.lines.join('\n');
+    }
+}
+export class TestTracker {
+    assertions = [];
+    totalTests = 0;
+    totalPassed = 0;
+    totalFailed = 0;
+    addAssertion(assertion) {
+        this.assertions.push(assertion);
+        this.totalTests++;
+        if (assertion.passed) {
+            this.totalPassed++;
+        }
+        else {
+            this.totalFailed++;
+        }
+    }
+    displayCurrentResults() {
+        if (this.assertions.length === 0) {
+            return '';
+        }
+        const lines = ['  📊 Test Results:'];
+        this.assertions.forEach((assertion) => {
+            const status = assertion.passed ? '✓' : '✗';
+            const name = assertion.assertion || assertion.name || 'Unnamed test';
+            lines.push(`    ${status} ${name}`);
+            if (!assertion.passed && assertion.error) {
+                const errorMessage = typeof assertion.error === 'string'
+                    ? assertion.error
+                    : assertion.error.message || 'Unknown error';
+                lines.push(`       └─ Error: ${errorMessage}`);
+            }
+        });
+        const passed = this.assertions.filter((a) => a.passed).length;
+        const failed = this.assertions.filter((a) => !a.passed).length;
+        lines.push(`    ────────────────────────────────────────`);
+        lines.push(`    ${this.assertions.length} tests | ✓ ${passed} passed | ✗ ${failed} failed\n`);
+        this.assertions.length = 0;
+        return lines.join('\n');
+    }
+    getTotalStats() {
+        return {
+            total: this.totalTests,
+            passed: this.totalPassed,
+            failed: this.totalFailed,
+        };
+    }
+    reset() {
+        this.assertions.length = 0;
+        this.totalTests = 0;
+        this.totalPassed = 0;
+        this.totalFailed = 0;
+    }
+}
+export function buildNewmanOptions(params, collection, environment) {
+    return {
+        collection: collection,
+        environment: environment,
+        iterationCount: params.iterationCount || 1,
+        timeout: params.requestTimeout || 60000,
+        timeoutRequest: params.requestTimeout || 60000,
+        timeoutScript: params.scriptTimeout || 5000,
+        delayRequest: 1000,
+        ignoreRedirects: false,
+        insecure: false,
+        bail: params.stopOnFailure ? ['failure'] : false,
+        suppressExitCode: true,
+        reporters: [],
+        reporter: {},
+        color: 'off',
+        verbose: false,
+        requestAgents: {
+            http: undefined,
+            https: undefined,
+        },
+    };
+}
+export async function executeCollection(context) {
+    const tracker = new TestTracker();
+    const output = new OutputBuilder();
+    output.add(`🚀 Starting collection: ${context.collection.name}`);
+    if (context.environment) {
+        output.add(`🌍 Using environment: ${context.environment.name}\n`);
+    }
+    const newmanOptions = buildNewmanOptions(context.params, context.collection.json, context.environment?.json);
+    const startTime = Date.now();
+    const summary = await runNewman(newmanOptions, tracker, output);
+    const endTime = Date.now();
+    const durationMs = endTime - startTime;
+    return {
+        output: output.build(),
+        testStats: tracker.getTotalStats(),
+        summary,
+        startTime,
+        endTime,
+        durationMs,
+    };
+}
+function runNewman(options, tracker, output) {
+    return new Promise((resolve, reject) => {
+        newman
+            .run(options)
+            .on('start', () => {
+            output.add('🎯 Starting collection run...\n');
+        })
+            .on('assertion', (_err, args) => {
+            if (args.assertion) {
+                tracker.addAssertion({
+                    passed: !args.error,
+                    assertion: args.assertion,
+                    name: args.assertion,
+                    error: args.error,
+                });
+            }
+        })
+            .on('item', (_err, args) => {
+            if (args.item) {
+                const testResults = tracker.displayCurrentResults();
+                if (testResults) {
+                    output.add(`\n📝 Request: ${args.item.name}`);
+                    output.add(testResults);
+                }
+            }
+        })
+            .on('done', (err, summary) => {
+            if (err) {
+                output.add('\n❌ Run error: ' + err.message);
+                reject(err);
+                return;
+            }
+            output.add('\n=== ✅ Run completed! ===');
+            appendSummaryToOutput(output, tracker, summary);
+            resolve(summary);
+        });
+    });
+}
+function appendSummaryToOutput(output, tracker, summary) {
+    const testStats = tracker.getTotalStats();
+    if (testStats.total > 0) {
+        output.add('\n📊 Overall Test Statistics:');
+        output.add(`  Total tests: ${testStats.total}`);
+        output.add(`  Passed: ${testStats.passed} ✅`);
+        output.add(`  Failed: ${testStats.failed} ❌`);
+        output.add(`  Success rate: ${((testStats.passed / testStats.total) * 100).toFixed(1)}%`);
+    }
+    if (summary?.run?.stats) {
+        output.add('\n📈 Request Summary:');
+        output.add(`  Total requests: ${summary.run.stats.requests?.total || 0}`);
+        output.add(`  Failed requests: ${summary.run.stats.requests?.failed || 0}`);
+        output.add(`  Total assertions: ${summary.run.stats.assertions?.total || 0}`);
+        output.add(`  Failed assertions: ${summary.run.stats.assertions?.failed || 0}`);
+        if (summary.run.stats.iterations) {
+            output.add(`  Total iterations: ${summary.run.stats.iterations.total || 0}`);
+            output.add(`  Failed iterations: ${summary.run.stats.iterations.failed || 0}`);
+        }
+    }
+}

package/dist/src/tools/runner/fetchers.js

@@ -0,0 +1,33 @@
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+export async function fetchCollection(collectionId, client) {
+    try {
+        const response = await client.get(`/collections/${collectionId}`);
+        const collectionJSON = response.collection || response;
+        return {
+            json: collectionJSON,
+            name: collectionJSON.info?.name || 'Unknown',
+            id: collectionId,
+        };
+    }
+    catch (error) {
+        throw new McpError(ErrorCode.InternalError, `Failed to fetch collection: ${collectionId}`, {
+            cause: error,
+        });
+    }
+}
+export async function fetchEnvironment(environmentId, client) {
+    try {
+        const response = await client.get(`/environments/${environmentId}`);
+        const environmentJSON = response.environment || response;
+        return {
+            json: environmentJSON,
+            name: environmentJSON.name || 'Unknown',
+            id: environmentId,
+        };
+    }
+    catch (error) {
+        throw new McpError(ErrorCode.InternalError, `Failed to fetch environment: ${environmentId}`, {
+            cause: error,
+        });
+    }
+}

package/dist/src/tools/runner/index.js

@@ -0,0 +1,20 @@
+import { fetchCollection, fetchEnvironment } from './fetchers.js';
+import { executeCollection } from './executor.js';
+import { parseToTelemetry, formatUserOutput } from './parsers.js';
+import { reportTelemetryAsync } from './telemetry.js';
+export async function runCollection(params, client) {
+    const collection = await fetchCollection(params.collectionId, client);
+    let environment;
+    if (params.environmentId) {
+        environment = await fetchEnvironment(params.environmentId, client);
+    }
+    const result = await executeCollection({
+        collection,
+        environment,
+        params,
+    });
+    const telemetryPayload = parseToTelemetry(result, params.collectionId, collection.name);
+    const userOutput = formatUserOutput(result);
+    reportTelemetryAsync(telemetryPayload, client);
+    return userOutput;
+}

package/dist/src/tools/runner/models.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/runner/parsers.js

@@ -0,0 +1,8 @@
+import { buildTelemetryPayload } from './telemetry.js';
+export function parseToTelemetry(result, collectionId, collectionName) {
+    return buildTelemetryPayload(collectionId, collectionName, result);
+}
+export function formatUserOutput(result) {
+    const durationSec = (result.durationMs / 1000).toFixed(2);
+    return `${result.output}\n⏱️  Duration: ${durationSec}s`;
+}

package/dist/src/tools/runner/telemetry.js

@@ -0,0 +1,178 @@
+import { RUNNER_ACCEPT_HEADER } from '../../constants.js';
+import { v4 as uuidv4 } from 'uuid';
+export function buildTelemetryPayload(collectionId, collectionName, result) {
+    const durationMs = result.durationMs;
+    const stats = result.summary?.run?.stats || {};
+    const iterations = stats.iterations || { total: 0, pending: 0, failed: 0 };
+    const items = stats.items || { total: 0, pending: 0, failed: 0 };
+    const scripts = stats.scripts || { total: 0, pending: 0, failed: 0 };
+    const prerequests = stats.prerequests || { total: 0, pending: 0, failed: 0 };
+    const requests = stats.requests || { total: 0, pending: 0, failed: 0 };
+    const tests = stats.tests || { total: 0, pending: 0, failed: 0 };
+    const assertions = stats.assertions || { total: 0, pending: 0, failed: 0 };
+    const testScripts = stats.testScripts || { total: 0, pending: 0, failed: 0 };
+    const prerequestScripts = stats.prerequestScripts || { total: 0, pending: 0, failed: 0 };
+    const responses = result.summary?.run?.executions || [];
+    const totalResponseTime = responses.reduce((sum, exec) => {
+        return sum + (exec?.response?.responseTime || 0);
+    }, 0);
+    const averageResponseTime = responses.length > 0 ? totalResponseTime / responses.length : 0;
+    const totalDataReceived = responses.reduce((sum, exec) => {
+        return sum + (exec?.response?.responseSize || 0);
+    }, 0);
+    const iterationsData = (result.summary?.run?.executions || []).map((exec) => {
+        const item = exec.item || {};
+        const request = exec.request || {};
+        const response = exec.response || {};
+        const assertions = exec.assertions || [];
+        const testResults = assertions.map((assertion) => ({
+            name: assertion.assertion || 'Unnamed test',
+            status: assertion.error ? 'fail' : 'pass',
+            error: assertion.error
+                ? {
+                    name: assertion.error.name || 'AssertionError',
+                    message: assertion.error.message || 'Unknown error',
+                    stack: assertion.error.stack || '',
+                }
+                : null,
+        }));
+        const requestData = {
+            url: request.url?.toString() || '',
+            method: request.method || 'GET',
+            headers: request.headers || {},
+        };
+        if (request.body) {
+            requestData.body = {
+                mode: request.body.mode || 'raw',
+                raw: request.body.raw || '',
+            };
+            if (request.body.options) {
+                requestData.body.options = request.body.options;
+            }
+        }
+        const responseData = {
+            code: response.code || 0,
+            name: response.status || '',
+            time: response.responseTime || 0,
+            size: response.responseSize || 0,
+            headers: response.headers || [],
+        };
+        if (response.stream) {
+            try {
+                responseData.body = response.stream.toString();
+            }
+            catch {
+                responseData.body = '';
+            }
+        }
+        return {
+            id: uuidv4(),
+            name: item.name || 'Request',
+            error: exec.requestError
+                ? {
+                    name: exec.requestError.name || 'Error',
+                    message: exec.requestError.message || 'Unknown error',
+                }
+                : null,
+            tests: testResults,
+            request: requestData,
+            response: responseData,
+        };
+    });
+    return {
+        collectionRun: {
+            id: uuidv4(),
+            collection: collectionId,
+            name: collectionName,
+            status: 'finished',
+            source: 'postman-cli',
+            delay: 0,
+            currentIteration: iterations.total || 1,
+            failedTestCount: result.testStats.failed,
+            skippedTestCount: 0,
+            passedTestCount: result.testStats.passed,
+            totalTestCount: result.testStats.total,
+            iterations: iterationsData.length > 0 ? [iterationsData] : [],
+            totalTime: durationMs,
+            totalRequests: requests.total || 0,
+            startedAt: result.startTime,
+            createdAt: result.endTime,
+            branchSource: 'local',
+            branch: process.env.GIT_BRANCH || 'main',
+        },
+        runOverview: {
+            collectionName: collectionName,
+            runDurationInMiliseconds: durationMs,
+            averageResponseTimeInMiliseconds: Math.round(averageResponseTime),
+            totalDataReceivedInBytes: totalDataReceived,
+            statistics: {
+                iterations: {
+                    total: iterations.total || 0,
+                    pending: iterations.pending || 0,
+                    failed: iterations.failed || 0,
+                },
+                items: {
+                    total: items.total || 0,
+                    pending: items.pending || 0,
+                    failed: items.failed || 0,
+                },
+                scripts: {
+                    total: scripts.total || 0,
+                    pending: scripts.pending || 0,
+                    failed: scripts.failed || 0,
+                },
+                prerequests: {
+                    total: prerequests.total || 0,
+                    pending: prerequests.pending || 0,
+                    failed: prerequests.failed || 0,
+                },
+                requests: {
+                    total: requests.total || 0,
+                    pending: requests.pending || 0,
+                    failed: requests.failed || 0,
+                },
+                tests: {
+                    total: tests.total || 0,
+                    pending: tests.pending || 0,
+                    failed: tests.failed || 0,
+                },
+                assertions: {
+                    total: assertions.total || 0,
+                    pending: assertions.pending || 0,
+                    failed: assertions.failed || 0,
+                },
+                testScripts: {
+                    total: testScripts.total || 0,
+                    pending: testScripts.pending || 0,
+                    failed: testScripts.failed || 0,
+                },
+                prerequestScripts: {
+                    total: prerequestScripts.total || 0,
+                    pending: prerequestScripts.pending || 0,
+                    failed: prerequestScripts.failed || 0,
+                },
+                responses: {
+                    total: responses.length || 0,
+                    pending: 0,
+                    failed: requests.failed || 0,
+                    totalResponseTime: Math.round(totalResponseTime),
+                },
+            },
+        },
+    };
+}
+export function reportTelemetryAsync(payload, client) {
+    setImmediate(async () => {
+        try {
+            await client.post('/collectionruns', {
+                body: JSON.stringify(payload),
+                headers: {
+                    Accept: RUNNER_ACCEPT_HEADER,
+                },
+            });
+        }
+        catch (error) {
+            console.error('[TelemetryReporter] Failed to post collection run data:', error.message);
+        }
+    });
+}

package/dist/src/tools/searchPostmanElements.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { asMcpError, McpError } from './utils/toolHelpers.js';
+export const method = 'searchPostmanElements';
+export const description = 'Searches for Postman elements in the public network.\n\n**When to Use This Tool:**\n- When the user asks for a specific named request (e.g., "find PayPal requests", "search for Stripe API requests")\n- When the user explicitly wants to search the public network\n- Do NOT use this for searching the user\'s own workspaces or collections (use getCollections or getWorkspaces instead)\n\n**Search Scope:**\n- Only searches the public network (public workspaces and collections)\n- Does not search private workspaces, team workspaces, or personal collections\n- Currently supports searching for requests (entityType: "requests")\n';
+export const parameters = z.object({
+    entityType: z
+        .literal('requests')
+        .describe('The type of Postman [entity](https://learning.postman.com/docs/getting-started/basics/postman-elements/) (element) to search for. At this time, this only accepts the `requests` value.'),
+    q: z
+        .string()
+        .min(1)
+        .max(512)
+        .describe('The query used to search for Postman elements.')
+        .optional(),
+    publisherIsVerified: z
+        .boolean()
+        .describe('Filter the search results to only return entities from publishers [verified](https://learning.postman.com/docs/collaborating-in-postman/public-api-network/verify-your-team/) by Postman.')
+        .optional(),
+    nextCursor: z
+        .string()
+        .describe('The cursor to get the next set of results in the paginated response. If you pass an invalid value, the API returns empty results.')
+        .optional(),
+    limit: z
+        .number()
+        .int()
+        .gte(1)
+        .lte(10)
+        .describe('The max number of search results returned in the response.')
+        .default(10),
+});
+export const annotations = {
+    title: 'Searches for Postman elements in the public network.\n\n**When to Use This Tool:**\n- When the user asks for a specific named request (e.g., "find PayPal requests", "search for Stripe API requests")\n- When the user explicitly wants to search the public network\n- Do NOT use this for searching the user\'s own workspaces or collections (use getCollections or getWorkspaces instead)\n\n**Search Scope:**\n- Only searches the public network (public workspaces and collections)\n- Does not search private workspaces, team workspaces, or personal collections\n- Currently supports searching for requests (entityType: "requests")\n',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+};
+export async function handler(args, extra) {
+    try {
+        const endpoint = `/search/${args.entityType}`;
+        const query = new URLSearchParams();
+        if (args.q !== undefined)
+            query.set('q', String(args.q));
+        if (args.publisherIsVerified !== undefined)
+            query.set('publisherIsVerified', String(args.publisherIsVerified));
+        if (args.nextCursor !== undefined)
+            query.set('nextCursor', String(args.nextCursor));
+        if (args.limit !== undefined)
+            query.set('limit', String(args.limit));
+        const url = query.toString() ? `${endpoint}?${query.toString()}` : endpoint;
+        const options = {
+            headers: extra.headers,
+        };
+        const result = await extra.client.get(url, options);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`,
+                },
+            ],
+        };
+    }
+    catch (e) {
+        if (e instanceof McpError) {
+            throw e;
+        }
+        throw asMcpError(e);
+    }
+}