@mcpflo/server-everything 0.0.1

package/dist/tools/simulate-research-query.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSimulateResearchQuery = registerSimulateResearchQuery;
+const zod_1 = require("zod");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const STAGES = ['Gathering sources', 'Analyzing content', 'Synthesizing findings', 'Generating report'];
+const STAGE_DURATION = 1000;
+const researchStates = new Map();
+async function runResearchProcess(taskId, taskStore, sendRequest) {
+    const state = researchStates.get(taskId);
+    if (!state)
+        return;
+    for (let i = state.currentStage; i < STAGES.length; i++) {
+        state.currentStage = i;
+        if (state.completed)
+            return;
+        await taskStore.updateTaskStatus(taskId, 'working', `${STAGES[i]}...`);
+        if (i === 2 && state.ambiguous && !state.clarification) {
+            await taskStore.updateTaskStatus(taskId, 'input_required', `Found multiple interpretations for "${state.topic}". Requesting clarification...`);
+            try {
+                const elicitResult = (await sendRequest({
+                    method: 'elicitation/create',
+                    params: {
+                        message: `The research query "${state.topic}" could have multiple interpretations. Please clarify what you're looking for:`,
+                        requestedSchema: {
+                            type: 'object',
+                            properties: {
+                                interpretation: {
+                                    type: 'string',
+                                    title: 'Clarification',
+                                    description: 'Which interpretation of the topic do you mean?',
+                                    oneOf: getInterpretationsForTopic(state.topic)
+                                }
+                            },
+                            required: ['interpretation']
+                        }
+                    }
+                }, types_js_1.ElicitResultSchema));
+                if (elicitResult.action === 'accept' && elicitResult.content) {
+                    state.clarification =
+                        elicitResult.content.interpretation ||
+                            'User accepted without selection';
+                }
+                else if (elicitResult.action === 'decline') {
+                    state.clarification = 'User declined - using default interpretation';
+                }
+                else {
+                    state.clarification = 'User cancelled - using default interpretation';
+                }
+            }
+            catch (error) {
+                console.warn(`Elicitation failed for task ${taskId}:`, error instanceof Error ? error.message : String(error));
+                state.clarification = 'technical (default - elicitation unavailable)';
+            }
+            await taskStore.updateTaskStatus(taskId, 'working', `Continuing with interpretation: "${state.clarification}"...`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, STAGE_DURATION));
+    }
+    state.completed = true;
+    const result = generateResearchReport(state);
+    state.result = result;
+    await taskStore.storeTaskResult(taskId, 'completed', result);
+}
+function generateResearchReport(state) {
+    const topic = state.clarification ? `${state.topic} (${state.clarification})` : state.topic;
+    const report = `# Research Report: ${topic}
+
+## Research Parameters
+- **Topic**: ${state.topic}
+${state.clarification ? `- **Clarification**: ${state.clarification}` : ''}
+
+## Synthesis
+This research query was processed through ${STAGES.length} stages:
+${STAGES.map((s, i) => `- Stage ${i + 1}: ${s} ✓`).join('\n')}
+
+---
+
+## About This Demo (SEP-1686: Tasks)
+
+This tool demonstrates MCP's task-based execution pattern for long-running operations:
+
+**Task Lifecycle Demonstrated:**
+1. \`tools/call\` with \`task\` parameter → Server returns \`CreateTaskResult\` (not the final result)
+2. Client polls \`tasks/get\` → Server returns current status and \`statusMessage\`
+3. Status progressed: \`working\` → ${state.clarification ? '`input_required` → `working` → ' : ''}\`completed\`
+4. Client calls \`tasks/result\` → Server returns this final result
+
+${state.clarification
+        ? `**Elicitation Flow:**
+When the query was ambiguous, the server sent an \`elicitation/create\` request
+to the client. The task status changed to \`input_required\` while awaiting user input.
+${state.clarification.includes('unavailable')
+            ? '**Note:** Elicitation failed and a default interpretation was used.'
+            : `After receiving clarification ("${state.clarification}"), the task resumed processing and completed.`}
+`
+        : ''}
+**Key Concepts:**
+- Tasks enable "call now, fetch later" patterns
+- \`statusMessage\` provides human-readable progress updates
+- Tasks have TTL (time-to-live) for automatic cleanup
+- \`pollInterval\` suggests how often to check status
+- Elicitation requests use \`relatedTask\` to queue via tasks/result (works on all transports)
+
+*This is a simulated research report. Demo/test fixture.*
+`;
+    return { content: [{ type: 'text', text: report }] };
+}
+function getInterpretationsForTopic(topic) {
+    const lowerTopic = topic.toLowerCase();
+    if (lowerTopic.includes('python')) {
+        return [
+            { const: 'programming', title: 'Python programming language' },
+            { const: 'snake', title: 'Python snake species' },
+            { const: 'comedy', title: 'Monty Python comedy group' }
+        ];
+    }
+    return [
+        { const: 'technical', title: 'Technical/scientific perspective' },
+        { const: 'historical', title: 'Historical perspective' },
+        { const: 'current', title: 'Current events/news perspective' }
+    ];
+}
+function registerSimulateResearchQuery(server) {
+    // Called from server.server.oninitialized (see index.ts), so the client's
+    // capabilities are already known here — computed once, not per-call, since
+    // capabilities don't change for the life of a session.
+    const clientCapabilities = server.server.getClientCapabilities() ?? {};
+    const clientSupportsElicitation = clientCapabilities.elicitation !== undefined;
+    server.experimental.tasks.registerToolTask('simulate-research-query', {
+        description: 'Simulates a deep research operation that gathers, analyzes, and synthesizes information. ' +
+            "Demonstrates MCP task-based operations with progress through multiple stages. If 'ambiguous' " +
+            'is true and the client supports elicitation, sends an elicitation request for clarification. ' +
+            'Demo/test fixture.',
+        inputSchema: {
+            topic: zod_1.z.string().describe('The research topic to investigate'),
+            ambiguous: zod_1.z
+                .boolean()
+                .default(false)
+                .describe('Simulate an ambiguous query that requires clarification (triggers input_required status)')
+        },
+        execution: { taskSupport: 'required' },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        }
+    }, {
+        createTask: async (args, extra) => {
+            const task = await extra.taskStore.createTask({ ttl: 300000, pollInterval: 1000 });
+            const state = {
+                topic: args.topic,
+                ambiguous: args.ambiguous && clientSupportsElicitation,
+                currentStage: 0,
+                completed: false
+            };
+            researchStates.set(task.taskId, state);
+            runResearchProcess(task.taskId, extra.taskStore, extra.sendRequest).catch((error) => {
+                console.error(`Research task ${task.taskId} failed:`, error);
+                extra.taskStore.updateTaskStatus(task.taskId, 'failed', String(error)).catch(console.error);
+            });
+            return { task };
+        },
+        getTask: async (_args, extra) => {
+            return await extra.taskStore.getTask(extra.taskId);
+        },
+        getTaskResult: async (_args, extra) => {
+            const result = await extra.taskStore.getTaskResult(extra.taskId);
+            researchStates.delete(extra.taskId);
+            return result;
+        }
+    });
+}

package/dist/tools/toggle-simulated-logging.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerToggleSimulatedLogging = registerToggleSimulatedLogging;
+const logging_1 = require("../server/logging");
+const activeSessions = new Set();
+function registerToggleSimulatedLogging(server) {
+    server.registerTool('toggle-simulated-logging', {
+        description: 'Toggles simulated, random-leveled logging on or off. Demo/test fixture.',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        }
+    }, async (extra) => {
+        const sessionId = extra.sessionId;
+        if (activeSessions.has(sessionId)) {
+            (0, logging_1.stopSimulatedLogging)(sessionId);
+            activeSessions.delete(sessionId);
+            return { content: [{ type: 'text', text: `Stopped simulated logging for session ${sessionId}` }] };
+        }
+        (0, logging_1.beginSimulatedLogging)(server, sessionId);
+        activeSessions.add(sessionId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Started simulated, random-leveled logging for session ${sessionId} at a 5 second pace. Client's selected logging level will be respected. If an interval elapses and the message to be sent is below the selected level, it will not be sent. Thus at higher chosen logging levels, messages should arrive further apart.`
+                }
+            ]
+        };
+    });
+}

package/dist/tools/toggle-subscriber-updates.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerToggleSubscriberUpdates = registerToggleSubscriberUpdates;
+const subscriptions_1 = require("../resources/subscriptions");
+const activeSessions = new Set();
+function registerToggleSubscriberUpdates(server) {
+    server.registerTool('toggle-subscriber-updates', {
+        description: 'Toggles simulated resource subscription updates on or off. Demo/test fixture.',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        }
+    }, async (extra) => {
+        const sessionId = extra.sessionId;
+        if (activeSessions.has(sessionId)) {
+            (0, subscriptions_1.stopSimulatedResourceUpdates)(sessionId);
+            activeSessions.delete(sessionId);
+            return { content: [{ type: 'text', text: `Stopped simulated resource updates for session ${sessionId}` }] };
+        }
+        (0, subscriptions_1.beginSimulatedResourceUpdates)(server, sessionId);
+        activeSessions.add(sessionId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Started simulated resource updated notifications for session ${sessionId} at a 5 second pace. Client will receive updates for any resources it is subscribed to.`
+                }
+            ]
+        };
+    });
+}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTriggerElicitationRequestAsync = registerTriggerElicitationRequestAsync;
+const zod_1 = require("zod");
+const POLL_INTERVAL = 1000;
+const MAX_POLL_ATTEMPTS = 600;
+function registerTriggerElicitationRequestAsync(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.elicitation === undefined)
+        return;
+    server.registerTool('trigger-elicitation-request-async', {
+        description: 'Trigger an async elicitation request that the CLIENT executes as a background task. ' +
+            'Demonstrates bidirectional MCP tasks where the server sends an elicitation request and ' +
+            'the client handles user input asynchronously, allowing the server to poll for completion. ' +
+            'Falls back gracefully if the client only supports synchronous elicitation. Demo/test fixture.',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        }
+    }, async (extra) => {
+        const elicitResponse = await extra.sendRequest({
+            method: 'elicitation/create',
+            params: {
+                task: { ttl: 600000 },
+                message: 'Please provide inputs for the following fields (async task demo):',
+                requestedSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { title: 'Your Name', type: 'string', description: 'Your full name' },
+                        favoriteColor: {
+                            title: 'Favorite Color',
+                            type: 'string',
+                            description: 'What is your favorite color?',
+                            enum: ['Red', 'Blue', 'Green', 'Yellow', 'Purple']
+                        },
+                        agreeToTerms: {
+                            title: 'Terms Agreement',
+                            type: 'boolean',
+                            description: 'Do you agree to the terms and conditions?'
+                        }
+                    },
+                    required: ['name']
+                }
+            }
+        }, 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({ action: zod_1.z.string(), content: zod_1.z.any().optional() })
+        ]));
+        const isTaskResult = 'task' in elicitResponse && elicitResponse.task;
+        if (!isTaskResult) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `[SYNC] Client executed synchronously:\n${JSON.stringify(elicitResponse, null, 2)}`
+                    }
+                ]
+            };
+        }
+        const taskId = elicitResponse.task.taskId;
+        const statusMessages = [`Task created: ${taskId}`];
+        let attempts = 0;
+        let taskStatus = elicitResponse.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;
+            if (attempts === 1 || attempts % 10 === 0 || taskStatus !== 'input_required') {
+                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());
+        const content = [];
+        if (result.action === 'accept' && result.content) {
+            content.push({ type: 'text', text: '[COMPLETED] User provided the requested information!' });
+            const userData = result.content;
+            const lines = [];
+            if (userData.name)
+                lines.push(`- Name: ${userData.name}`);
+            if (userData.favoriteColor)
+                lines.push(`- Favorite Color: ${userData.favoriteColor}`);
+            if (userData.agreeToTerms !== undefined)
+                lines.push(`- Agreed to terms: ${userData.agreeToTerms}`);
+            content.push({ type: 'text', text: `User inputs:\n${lines.join('\n')}` });
+        }
+        else if (result.action === 'decline') {
+            content.push({ type: 'text', text: '[DECLINED] User declined to provide the requested information.' });
+        }
+        else if (result.action === 'cancel') {
+            content.push({ type: 'text', text: '[CANCELLED] User cancelled the elicitation dialog.' });
+        }
+        content.push({
+            type: 'text',
+            text: `\nProgress:\n${statusMessages.join('\n')}\n\nRaw result: ${JSON.stringify(result, null, 2)}`
+        });
+        return { content };
+    });
+}

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTriggerElicitationRequest = registerTriggerElicitationRequest;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+function registerTriggerElicitationRequest(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.elicitation === undefined)
+        return;
+    server.registerTool('trigger-elicitation-request', {
+        description: 'Trigger a request from the server for user elicitation. Demo/test fixture.',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        }
+    }, async (extra) => {
+        const elicitationResult = await extra.sendRequest({
+            method: 'elicitation/create',
+            params: {
+                message: 'Please provide inputs for the following fields:',
+                requestedSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { title: 'String', type: 'string', description: 'Your full, legal name' },
+                        check: { title: 'Boolean', type: 'boolean', description: 'Agree to the terms and conditions' },
+                        firstLine: {
+                            title: 'String with default',
+                            type: 'string',
+                            description: 'Favorite first line of a story',
+                            default: 'It was a dark and stormy night.'
+                        },
+                        email: {
+                            title: 'String with email format',
+                            type: 'string',
+                            format: 'email',
+                            description: 'Your email address (will be verified, and never shared with anyone else)'
+                        },
+                        homepage: {
+                            type: 'string',
+                            format: 'uri',
+                            title: 'String with uri format',
+                            description: 'Portfolio / personal website'
+                        },
+                        birthdate: {
+                            title: 'String with date format',
+                            type: 'string',
+                            format: 'date',
+                            description: 'Your date of birth'
+                        },
+                        integer: {
+                            title: 'Integer',
+                            type: 'integer',
+                            description: 'Your favorite integer (do not give us your phone number, pin, or other sensitive info)',
+                            minimum: 1,
+                            maximum: 100,
+                            default: 42
+                        },
+                        number: {
+                            title: 'Number in range 1-1000',
+                            type: 'number',
+                            description: 'Favorite number (there are no wrong answers)',
+                            minimum: 0,
+                            maximum: 1000,
+                            default: 3.14
+                        },
+                        untitledSingleSelectEnum: {
+                            type: 'string',
+                            title: 'Untitled Single Select Enum',
+                            description: 'Choose your favorite friend',
+                            enum: ['Monica', 'Rachel', 'Joey', 'Chandler', 'Ross', 'Phoebe'],
+                            default: 'Monica'
+                        },
+                        untitledMultipleSelectEnum: {
+                            type: 'array',
+                            title: 'Untitled Multiple Select Enum',
+                            description: 'Choose your favorite instruments',
+                            minItems: 1,
+                            maxItems: 3,
+                            items: { type: 'string', enum: ['Guitar', 'Piano', 'Violin', 'Drums', 'Bass'] },
+                            default: ['Guitar']
+                        },
+                        titledSingleSelectEnum: {
+                            type: 'string',
+                            title: 'Titled Single Select Enum',
+                            description: 'Choose your favorite hero',
+                            oneOf: [
+                                { const: 'hero-1', title: 'Superman' },
+                                { const: 'hero-2', title: 'Green Lantern' },
+                                { const: 'hero-3', title: 'Wonder Woman' }
+                            ],
+                            default: 'hero-1'
+                        },
+                        titledMultipleSelectEnum: {
+                            type: 'array',
+                            title: 'Titled Multiple Select Enum',
+                            description: 'Choose your favorite types of fish',
+                            minItems: 1,
+                            maxItems: 3,
+                            items: {
+                                anyOf: [
+                                    { const: 'fish-1', title: 'Tuna' },
+                                    { const: 'fish-2', title: 'Salmon' },
+                                    { const: 'fish-3', title: 'Trout' }
+                                ]
+                            },
+                            default: ['fish-1']
+                        },
+                        legacyTitledEnum: {
+                            type: 'string',
+                            title: 'Legacy Titled Single Select Enum',
+                            description: 'Choose your favorite type of pet',
+                            enum: ['pet-1', 'pet-2', 'pet-3', 'pet-4', 'pet-5'],
+                            enumNames: ['Cats', 'Dogs', 'Birds', 'Fish', 'Reptiles'],
+                            default: 'pet-1'
+                        }
+                    },
+                    required: ['name']
+                }
+            }
+        }, types_js_1.ElicitResultSchema, { timeout: 10 * 60 * 1000 });
+        const content = [];
+        if (elicitationResult.action === 'accept' && elicitationResult.content) {
+            content.push({ type: 'text', text: '✅ User provided the requested information!' });
+            const userData = elicitationResult.content;
+            const lines = [];
+            if (userData.name)
+                lines.push(`- Name: ${userData.name}`);
+            if (userData.check !== undefined)
+                lines.push(`- Agreed to terms: ${userData.check}`);
+            if (userData.firstLine)
+                lines.push(`- Favorite first line: ${userData.firstLine}`);
+            if (userData.email)
+                lines.push(`- Email: ${userData.email}`);
+            if (userData.homepage)
+                lines.push(`- Homepage: ${userData.homepage}`);
+            if (userData.birthdate)
+                lines.push(`- Birthdate: ${userData.birthdate}`);
+            if (userData.integer !== undefined)
+                lines.push(`- Favorite Integer: ${userData.integer}`);
+            if (userData.number !== undefined)
+                lines.push(`- Favorite Number: ${userData.number}`);
+            if (userData.untitledSingleSelectEnum)
+                lines.push(`- Favorite friend: ${userData.untitledSingleSelectEnum}`);
+            if (userData.untitledMultipleSelectEnum)
+                lines.push(`- Favorite instruments: ${userData.untitledMultipleSelectEnum}`);
+            if (userData.titledSingleSelectEnum)
+                lines.push(`- Favorite hero: ${userData.titledSingleSelectEnum}`);
+            if (userData.titledMultipleSelectEnum)
+                lines.push(`- Favorite fish: ${userData.titledMultipleSelectEnum}`);
+            if (userData.legacyTitledEnum)
+                lines.push(`- Favorite pet type: ${userData.legacyTitledEnum}`);
+            content.push({ type: 'text', text: `User inputs:\n${lines.join('\n')}` });
+        }
+        else if (elicitationResult.action === 'decline') {
+            content.push({ type: 'text', text: '❌ User declined to provide the requested information.' });
+        }
+        else if (elicitationResult.action === 'cancel') {
+            content.push({ type: 'text', text: '⚠️ User cancelled the elicitation dialog.' });
+        }
+        content.push({ type: 'text', text: `\nRaw result: ${JSON.stringify(elicitationResult, null, 2)}` });
+        return { content };
+    });
+}

package/dist/tools/trigger-long-running-operation.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTriggerLongRunningOperation = registerTriggerLongRunningOperation;
+const zod_1 = require("zod");
+function registerTriggerLongRunningOperation(server) {
+    server.registerTool('trigger-long-running-operation', {
+        description: 'Demonstrates a long running operation with progress updates. Demo/test fixture.',
+        inputSchema: {
+            duration: zod_1.z.number().default(10).describe('Duration of the operation in seconds'),
+            steps: zod_1.z.number().default(5).describe('Number of steps in the operation')
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ duration, steps }, extra) => {
+        const stepDuration = duration / steps;
+        const progressToken = extra._meta?.progressToken;
+        for (let i = 1; i < steps + 1; i++) {
+            await new Promise((resolve) => setTimeout(resolve, stepDuration * 1000));
+            if (progressToken !== undefined) {
+                await server.server.notification({
+                    method: 'notifications/progress',
+                    params: { progress: i, total: steps, progressToken }
+                }, { relatedRequestId: extra.requestId });
+            }
+        }
+        return {
+            content: [
+                { type: 'text', text: `Long running operation completed. Duration: ${duration} seconds, Steps: ${steps}.` }
+            ]
+        };
+    });
+}