@mcpflo/server-everything 0.0.1

package/dist/tools/trigger-sampling-request-async.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTriggerSamplingRequestAsync = registerTriggerSamplingRequestAsync;
+const zod_1 = require("zod");
+const POLL_INTERVAL = 1000;
+const MAX_POLL_ATTEMPTS = 60;
+function registerTriggerSamplingRequestAsync(server) {
+    // Called from server.server.oninitialized (see index.ts), so the client's
+    // capabilities are already known here — this is not a registration-time
+    // race like it would be if called eagerly at server construction.
+    const clientCapabilities = server.server.getClientCapabilities() ?? {};
+    if (clientCapabilities.sampling === undefined)
+        return;
+    server.registerTool('trigger-sampling-request-async', {
+        description: 'Trigger an async sampling request that the CLIENT executes as a background task. ' +
+            'Demonstrates bidirectional MCP tasks where the server sends a request and the client ' +
+            'executes it asynchronously, allowing the server to poll for progress and results. ' +
+            'Falls back gracefully if the client only supports synchronous sampling. Demo/test fixture.',
+        inputSchema: {
+            prompt: zod_1.z.string().describe('The prompt to send to the LLM'),
+            maxTokens: zod_1.z.number().default(100).describe('Maximum number of tokens to generate')
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true
+        }
+    }, async ({ prompt, maxTokens }, extra) => {
+        const samplingResponse = await extra.sendRequest({
+            method: 'sampling/createMessage',
+            params: {
+                task: { ttl: 300000 },
+                messages: [{ role: 'user', content: { type: 'text', text: prompt } }],
+                systemPrompt: 'You are a helpful test server.',
+                maxTokens,
+                temperature: 0.7
+            }
+        }, zod_1.z.union([
+            zod_1.z.object({
+                task: zod_1.z.object({
+                    taskId: zod_1.z.string(),
+                    status: zod_1.z.string(),
+                    pollInterval: zod_1.z.number().optional(),
+                    statusMessage: zod_1.z.string().optional()
+                })
+            }),
+            zod_1.z.object({
+                role: zod_1.z.string(),
+                content: zod_1.z.any(),
+                model: zod_1.z.string(),
+                stopReason: zod_1.z.string().optional()
+            })
+        ]));
+        const isTaskResult = 'task' in samplingResponse && samplingResponse.task;
+        if (!isTaskResult) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `[SYNC] Client executed synchronously:\n${JSON.stringify(samplingResponse, null, 2)}`
+                    }
+                ]
+            };
+        }
+        const taskId = samplingResponse.task.taskId;
+        const statusMessages = [`Task created: ${taskId}`];
+        let attempts = 0;
+        let taskStatus = samplingResponse.task.status;
+        let taskStatusMessage;
+        while (taskStatus !== 'completed' &&
+            taskStatus !== 'failed' &&
+            taskStatus !== 'cancelled' &&
+            attempts < MAX_POLL_ATTEMPTS) {
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+            attempts++;
+            const pollResult = await extra.sendRequest({ method: 'tasks/get', params: { taskId } }, zod_1.z.looseObject({ status: zod_1.z.string(), statusMessage: zod_1.z.string().optional() }));
+            taskStatus = pollResult.status;
+            taskStatusMessage = pollResult.statusMessage;
+            statusMessages.push(`Poll ${attempts}: ${taskStatus}${taskStatusMessage ? ` - ${taskStatusMessage}` : ''}`);
+        }
+        if (attempts >= MAX_POLL_ATTEMPTS) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `[TIMEOUT] Task timed out after ${MAX_POLL_ATTEMPTS} poll attempts\n\nProgress:\n${statusMessages.join('\n')}`
+                    }
+                ]
+            };
+        }
+        if (taskStatus === 'failed' || taskStatus === 'cancelled') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `[${taskStatus.toUpperCase()}] ${taskStatusMessage || 'No message'}\n\nProgress:\n${statusMessages.join('\n')}`
+                    }
+                ]
+            };
+        }
+        const result = await extra.sendRequest({ method: 'tasks/result', params: { taskId } }, zod_1.z.any());
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `[COMPLETED] Async sampling completed!\n\n**Progress:**\n${statusMessages.join('\n')}\n\n**Result:**\n${JSON.stringify(result, null, 2)}`
+                }
+            ]
+        };
+    });
+}

package/dist/tools/trigger-sampling-request.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTriggerSamplingRequest = registerTriggerSamplingRequest;
+const zod_1 = require("zod");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+function registerTriggerSamplingRequest(server) {
+    // Called from server.server.oninitialized (see index.ts), so the client's
+    // capabilities are already known here — this is not a registration-time
+    // race like it would be if called eagerly at server construction.
+    const clientCapabilities = server.server.getClientCapabilities() ?? {};
+    if (clientCapabilities.sampling === undefined)
+        return;
+    server.registerTool('trigger-sampling-request', {
+        description: 'Trigger a request from the server for LLM sampling. Demo/test fixture.',
+        inputSchema: {
+            prompt: zod_1.z.string().describe('The prompt to send to the LLM'),
+            maxTokens: zod_1.z.number().default(100).describe('Maximum number of tokens to generate')
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true
+        }
+    }, async ({ prompt, maxTokens }, extra) => {
+        const result = await extra.sendRequest({
+            method: 'sampling/createMessage',
+            params: {
+                messages: [{ role: 'user', content: { type: 'text', text: prompt } }],
+                systemPrompt: 'You are a helpful test server.',
+                maxTokens,
+                temperature: 0.7
+            }
+        }, types_js_1.CreateMessageResultSchema);
+        return {
+            content: [{ type: 'text', text: `LLM sampling result: \n${JSON.stringify(result, null, 2)}` }]
+        };
+    });
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mcpflo/server-everything",
+  "version": "0.0.1",
+  "description": "Deterministic MCP test-fixture server for MCPFlo",
+  "mcpName": "io.github.harshalslimaye/mcpflo-server-everything",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harshalslimaye/mcpflo.git",
+    "directory": "packages/server-everything"
+  },
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "bin": {
+    "mcpflo-server-everything": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('fs').cpSync('docs','dist/docs',{recursive:true})\"",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "vitest": "4.1.8"
+  }
+}