@vrdmr/fnx-test 0.1.1

package/lib/live-mcp-server.js

@@ -0,0 +1,382 @@
+/**
+ * Live MCP server — exposes running host data over HTTP Streamable transport.
+ * Started automatically when `fnx start` launches.
+ *
+ * Tools:
+ *   get_host_status    — host version, state, uptime, PID, SKU, worker runtime
+ *   get_functions      — list of functions with trigger types and routes
+ *   get_invocations    — recent invocation log (ring buffer)
+ *   invoke_function    — trigger an HTTP function via its route
+ *   get_app_settings   — merged config with secrets redacted
+ *   get_errors         — recent host errors
+ */
+
+import { createServer as createHttpServer } from 'node:http';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesMcpDir = join(__dirname, '..', 'templates-mcp');
+
+// Resolve MCP SDK from templates-mcp's node_modules
+const require = createRequire(join(templatesMcpDir, 'package.json'));
+
+// ─── Tool registration (called per session) ─────────────────────────
+
+function registerTools(server, hostState, z) {
+  server.registerTool(
+    'get_host_status',
+    {
+      title: 'Get Host Status',
+      description: `Get the current state of the running Azure Functions host.
+Returns: host version, state, uptime, PID, SKU, extension bundle version, worker runtime, port.
+Use this first to check if the host is healthy before querying functions or invocations.`,
+      inputSchema: z.object({}),
+    },
+    async () => {
+      const uptimeMs = Date.now() - hostState.startedAt;
+      const uptimeMin = (uptimeMs / 60000).toFixed(1);
+      const totalInvocations = hostState.invocations.length;
+      const failedCount = hostState.invocations.filter(i => i.status !== 'Succeeded').length;
+
+      let text = `# Host Status\n\n`;
+      text += `| Property | Value |\n|---|---|\n`;
+      text += `| State | ${hostState.state} |\n`;
+      text += `| PID | ${hostState.pid || 'N/A'} |\n`;
+      text += `| Uptime | ${uptimeMin} minutes |\n`;
+      text += `| Host Version | ${hostState.hostVersion} |\n`;
+      text += `| SKU | ${hostState.skuName} |\n`;
+      text += `| Extension Bundle | ${hostState.extensionBundleVersion} |\n`;
+      text += `| Worker Runtime | ${hostState.workerRuntime} |\n`;
+      text += `| Port | ${hostState.port} |\n`;
+      text += `| Base URL | ${hostState.baseUrl || 'not yet listening'} |\n`;
+      text += `| Total Invocations | ${totalInvocations} |\n`;
+      text += `| Failed Invocations | ${failedCount} |\n`;
+      text += `| Errors | ${hostState.errors.length} |\n`;
+
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+
+  server.registerTool(
+    'get_functions',
+    {
+      title: 'Get Functions',
+      description: `List all functions in the running app with trigger types, routes, and methods.
+Returns HTTP functions (with route and allowed methods) and non-HTTP functions (blob, timer, queue triggers).`,
+      inputSchema: z.object({}),
+    },
+    async () => {
+      const http = hostState.httpFunctions || [];
+      const nonHttp = hostState.nonHttpFunctions || [];
+
+      if (http.length === 0 && nonHttp.length === 0) {
+        return { content: [{ type: 'text', text: 'No functions discovered yet. The host may still be starting.' }] };
+      }
+
+      let text = `# Functions (${http.length + nonHttp.length} total)\n\n`;
+
+      if (http.length > 0) {
+        text += `## HTTP Functions\n\n`;
+        text += `| Function | Methods | Route | URL |\n|---|---|---|---|\n`;
+        for (const fn of http) {
+          const url = hostState.baseUrl ? `${hostState.baseUrl}/${fn.route}` : fn.route;
+          text += `| ${fn.name} | ${fn.methods} | /${fn.route} | ${url} |\n`;
+        }
+        text += `\n`;
+      }
+
+      if (nonHttp.length > 0) {
+        text += `## Non-HTTP Functions\n\n`;
+        text += `| Function | Trigger Type |\n|---|---|\n`;
+        for (const fn of nonHttp) {
+          text += `| ${fn.name} | ${fn.triggerType} |\n`;
+        }
+      }
+
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+
+  server.registerTool(
+    'get_invocations',
+    {
+      title: 'Get Invocations',
+      description: `Get recent function invocations with status, duration, and trigger reason.
+Filterable by function name and status. Returns newest first (up to 200 stored).`,
+      inputSchema: z.object({
+        functionName: z.string().optional().describe('Filter by function name'),
+        status: z.string().optional().describe('Filter by status: Succeeded, Failed'),
+        limit: z.number().optional().describe('Max results to return (default: 20)'),
+      }),
+    },
+    async (args) => {
+      let invocations = [...hostState.invocations].reverse();
+
+      if (args.functionName) {
+        invocations = invocations.filter(i => i.functionName === args.functionName);
+      }
+      if (args.status) {
+        invocations = invocations.filter(i => i.status === args.status);
+      }
+
+      const limit = args.limit || 20;
+      invocations = invocations.slice(0, limit);
+
+      if (invocations.length === 0) {
+        return { content: [{ type: 'text', text: 'No invocations recorded yet.' }] };
+      }
+
+      let text = `# Recent Invocations (${invocations.length})\n\n`;
+      text += `| Function | Status | Duration | Reason | Time |\n|---|---|---|---|---|\n`;
+      for (const inv of invocations) {
+        text += `| ${inv.functionName} | ${inv.status} | ${inv.durationMs}ms | ${inv.reason} | ${inv.timestamp} |\n`;
+      }
+
+      const succeeded = hostState.invocations.filter(i => i.status === 'Succeeded').length;
+      const failed = hostState.invocations.filter(i => i.status !== 'Succeeded').length;
+      const avgDuration = hostState.invocations.length > 0
+        ? (hostState.invocations.reduce((sum, i) => sum + i.durationMs, 0) / hostState.invocations.length).toFixed(0)
+        : 0;
+
+      text += `\n**Summary**: ${succeeded} succeeded, ${failed} failed, avg ${avgDuration}ms\n`;
+
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+
+  server.registerTool(
+    'invoke_function',
+    {
+      title: 'Invoke Function',
+      description: `Invoke an HTTP function by name. Sends a request to the function's route and returns the response.
+Only HTTP functions can be invoked. For non-HTTP, upload data to the trigger source (e.g., blob to storage).`,
+      inputSchema: z.object({
+        functionName: z.string().describe('Name of the HTTP function to invoke'),
+        method: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional().describe('HTTP method (default: GET)'),
+        body: z.string().optional().describe('Request body (for POST/PUT)'),
+        queryString: z.string().optional().describe('Query string to append (e.g., "name=World")'),
+      }),
+    },
+    async (args) => {
+      const fn = (hostState.httpFunctions || []).find(f => f.name === args.functionName);
+      if (!fn) {
+        const available = (hostState.httpFunctions || []).map(f => f.name).join(', ');
+        return {
+          content: [{ type: 'text', text: `Function "${args.functionName}" not found or not an HTTP function. Available: ${available || 'none'}` }],
+          isError: true,
+        };
+      }
+
+      if (!hostState.baseUrl) {
+        return { content: [{ type: 'text', text: 'Host is not yet listening. Wait for startup to complete.' }], isError: true };
+      }
+
+      let url = `${hostState.baseUrl}/${fn.route}`;
+      if (args.queryString) url += `?${args.queryString}`;
+
+      const method = args.method || 'GET';
+      const fetchOpts = { method };
+      if (args.body && (method === 'POST' || method === 'PUT')) {
+        fetchOpts.body = args.body;
+        fetchOpts.headers = { 'Content-Type': 'application/json' };
+      }
+
+      try {
+        const response = await fetch(url, fetchOpts);
+        const responseText = await response.text();
+        let text = `# Invocation Result\n\n`;
+        text += `**URL**: ${method} ${url}\n`;
+        text += `**Status**: ${response.status} ${response.statusText}\n\n`;
+        text += `**Response**:\n\`\`\`\n${responseText}\n\`\`\`\n`;
+        return { content: [{ type: 'text', text }] };
+      } catch (err) {
+        return {
+          content: [{ type: 'text', text: `Failed to invoke: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.registerTool(
+    'get_app_settings',
+    {
+      title: 'Get App Settings',
+      description: `Get merged app settings (app.config.json + local.settings.json) with secrets redacted.
+Shows environment variables injected into the host process.`,
+      inputSchema: z.object({}),
+    },
+    async () => {
+      const settings = hostState.appSettings || {};
+      if (Object.keys(settings).length === 0) {
+        return { content: [{ type: 'text', text: 'No app settings available.' }] };
+      }
+
+      let text = `# App Settings\n\n`;
+      text += `| Key | Value |\n|---|---|\n`;
+      for (const [key, value] of Object.entries(settings)) {
+        text += `| ${key} | ${value} |\n`;
+      }
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+
+  server.registerTool(
+    'get_errors',
+    {
+      title: 'Get Errors',
+      description: `Get recent host errors and failures with timestamps.
+Quick health check without digging through verbose logs.`,
+      inputSchema: z.object({}),
+    },
+    async () => {
+      if (hostState.errors.length === 0) {
+        return { content: [{ type: 'text', text: '✅ No errors recorded.' }] };
+      }
+
+      let text = `# Host Errors (${hostState.errors.length})\n\n`;
+      for (const err of hostState.errors.slice(-20)) {
+        text += `- **${err.timestamp}**: ${err.message}\n`;
+      }
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+// ─── Start live MCP server ──────────────────────────────────────────
+
+export async function startLiveMcpServer(hostState, mcpPort) {
+  const { McpServer } = await import(require.resolve('@modelcontextprotocol/sdk/server/mcp.js'));
+  const { StreamableHTTPServerTransport } = await import(
+    require.resolve('@modelcontextprotocol/sdk/server/streamableHttp.js')
+  );
+  const { z } = await import(require.resolve('zod'));
+  const { randomUUID } = await import('node:crypto');
+
+  // Factory: create a new McpServer per session (SDK requirement)
+  function createMcpServer() {
+    const server = new McpServer({
+      name: 'fnx-live',
+      version: '0.1.0',
+    });
+
+    registerTools(server, hostState, z);
+    return server;
+  }
+
+  // ─── Start HTTP server with Streamable HTTP transport ───────────────
+
+  const transports = new Map(); // sessionId → { transport, server }
+
+  const httpServer = createHttpServer(async (req, res) => {
+    // CORS headers for browser-based MCP clients
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, mcp-session-id, Accept');
+    res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Health check endpoint
+    if (req.url === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', hostState: hostState.state }));
+      return;
+    }
+
+    // MCP endpoint at /mcp
+    if (req.url === '/mcp' || req.url?.startsWith('/mcp?')) {
+      try {
+        const sessionId = req.headers['mcp-session-id'];
+
+        if (req.method === 'POST') {
+          // Existing session: reuse transport
+          if (sessionId && transports.has(sessionId)) {
+            const { transport } = transports.get(sessionId);
+            await transport.handleRequest(req, res);
+            return;
+          }
+
+          // New session: create server + transport pair
+          const mcpServer = createMcpServer();
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sid) => {
+              transports.set(sid, { transport, server: mcpServer });
+            },
+          });
+
+          transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid) transports.delete(sid);
+          };
+
+          await mcpServer.connect(transport);
+          await transport.handleRequest(req, res);
+          return;
+        }
+
+        if (req.method === 'GET') {
+          // SSE stream for notifications
+          if (sessionId && transports.has(sessionId)) {
+            const { transport } = transports.get(sessionId);
+            await transport.handleRequest(req, res);
+            return;
+          }
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Missing or invalid session ID for GET (SSE) request' }));
+          return;
+        }
+
+        if (req.method === 'DELETE') {
+          if (sessionId && transports.has(sessionId)) {
+            const { transport, server: mcpServer } = transports.get(sessionId);
+            await transport.handleRequest(req, res);
+            transports.delete(sessionId);
+            await mcpServer.close();
+            return;
+          }
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Session not found' }));
+          return;
+        }
+
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method not allowed. Use POST, GET, or DELETE.' }));
+      } catch (err) {
+        console.error('[MCP] Error handling request:', err.message);
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      }
+      return;
+    }
+
+    // 404 for everything else
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found. MCP endpoint is at /mcp' }));
+  });
+
+  return new Promise((resolve, reject) => {
+    httpServer.on('error', (err) => {
+      // Only reject during startup; after that, log and continue
+      if (!httpServer.listening) {
+        reject(err);
+      } else {
+        console.error(`  ⚠️  MCP server error: ${err.message}`);
+      }
+    });
+
+    httpServer.listen(mcpPort, '127.0.0.1', () => {
+      console.log(`  MCP Server:      http://127.0.0.1:${mcpPort}/mcp (Streamable HTTP)`);
+      resolve(httpServer);
+    });
+  });
+}

package/lib/mcp-server.js

@@ -0,0 +1,144 @@
+/**
+ * Hand-rolled JSON-RPC 2.0 MCP server over stdio.
+ * Zero npm dependencies — uses only Node.js builtins.
+ *
+ * Supports: initialize, notifications/initialized, tools/list, tools/call, ping
+ */
+
+import { createInterface } from 'node:readline';
+
+const PROTOCOL_VERSION = '2024-11-05';
+
+/**
+ * Creates and runs an MCP server over stdio.
+ *
+ * @param {object} opts
+ * @param {string} opts.name - Server name
+ * @param {string} opts.version - Server version
+ * @param {Array<{name: string, description: string, inputSchema: object, handler: function}>} opts.tools - Tool definitions
+ */
+export async function runStdioMcpServer({ name, version, tools }) {
+  const toolMap = new Map();
+  for (const tool of tools) {
+    toolMap.set(tool.name, tool);
+  }
+
+  function sendResponse(response) {
+    const json = JSON.stringify(response);
+    return new Promise((resolve) => {
+      process.stdout.write(json + '\n', resolve);
+    });
+  }
+
+  // Track pending async tool calls so we don't exit before they complete
+  const pending = new Set();
+
+  function handleMessage(msg) {
+    // Notifications have no id — no response needed
+    if (msg.id === undefined || msg.id === null) {
+      return; // e.g. notifications/initialized
+    }
+
+    const { id, method, params } = msg;
+
+    if (method === 'initialize') {
+      sendResponse({
+        jsonrpc: '2.0',
+        id,
+        result: {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: { name, version },
+        },
+      });
+      return;
+    }
+
+    if (method === 'ping') {
+      sendResponse({ jsonrpc: '2.0', id, result: {} });
+      return;
+    }
+
+    if (method === 'tools/list') {
+      const toolList = tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema || { type: 'object', properties: {} },
+      }));
+      sendResponse({ jsonrpc: '2.0', id, result: { tools: toolList } });
+      return;
+    }
+
+    if (method === 'tools/call') {
+      const toolName = params?.name;
+      const toolArgs = params?.arguments || {};
+      const tool = toolMap.get(toolName);
+
+      if (!tool) {
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: `Unknown tool: ${toolName}` }],
+            isError: true,
+          },
+        });
+        return;
+      }
+
+      // Call handler async, track the promise
+      const p = Promise.resolve(tool.handler(toolArgs))
+        .then((result) => {
+          sendResponse({ jsonrpc: '2.0', id, result });
+        })
+        .catch((err) => {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{ type: 'text', text: `Tool error: ${err.message}` }],
+              isError: true,
+            },
+          });
+        })
+        .finally(() => pending.delete(p));
+      pending.add(p);
+      return;
+    }
+
+    // Unknown method
+    sendResponse({
+      jsonrpc: '2.0',
+      id,
+      error: { code: -32601, message: `Method not found: ${method}` },
+    });
+  }
+
+  // Read newline-delimited JSON from stdin
+  const rl = createInterface({ input: process.stdin });
+  let stdinClosed = false;
+
+  rl.on('line', (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      const msg = JSON.parse(trimmed);
+      handleMessage(msg);
+    } catch (err) {
+      process.stderr.write(`[MCP] Parse error: ${err.message}\n`);
+    }
+  });
+
+  rl.on('close', async () => {
+    stdinClosed = true;
+    // Wait for any in-flight tool calls to complete before exiting
+    if (pending.size > 0) {
+      await Promise.allSettled([...pending]);
+    }
+    process.exit(0);
+  });
+
+  // Handle signals gracefully
+  process.on('SIGINT', () => process.exit(0));
+  process.on('SIGTERM', () => process.exit(0));
+}

package/lib/mcp-tools/sku.js

@@ -0,0 +1,136 @@
+/**
+ * MCP SKU tool definitions for the hand-rolled MCP server.
+ * Uses profile-resolver to read SKU profiles (bundled/cached/CDN).
+ *
+ * Tools: get_sku_profile, compare_skus
+ */
+
+import { resolveProfile, listProfiles } from '../profile-resolver.js';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_PROFILES_PATH = join(__dirname, '..', '..', 'profiles', 'sku-profiles.json');
+
+async function loadAllProfiles() {
+  // Try bundled profiles directly (fast, no network)
+  const raw = await readFile(BUNDLED_PROFILES_PATH, 'utf-8');
+  return JSON.parse(raw);
+}
+
+export function getSkuTools() {
+  return [
+    {
+      name: 'get_sku_profile',
+      description:
+        `Get SKU profile details for Azure Functions hosting plans.\n\n` +
+        `Returns host version, extension bundle version, status, and notes.\n` +
+        `Call with no arguments to list all SKUs, or provide a SKU name for details.\n` +
+        `Use this to check SKU compatibility before suggesting features.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          sku: {
+            type: 'string',
+            description:
+              'SKU name (e.g., flex, linux-premium, windows-consumption). Omit to list all.',
+          },
+        },
+      },
+      async handler(args) {
+        try {
+          if (args.sku) {
+            const profile = await resolveProfile(args.sku);
+            let text = `# SKU Profile: ${profile.displayName}\n\n`;
+            text += `| Property | Value |\n|---|---|\n`;
+            text += `| SKU Key | ${args.sku} |\n`;
+            text += `| Display Name | ${profile.displayName} |\n`;
+            text += `| Host Version | ${profile.hostVersion} |\n`;
+            text += `| Host Git Tag | ${profile.hostGitTag} |\n`;
+            text += `| Extension Bundle | ${profile.extensionBundleVersion} |\n`;
+            text += `| Max Bundle Version | ${profile.maxExtensionBundleVersion || 'n/a'} |\n`;
+            text += `| Status | ${profile.status} |\n`;
+            if (profile.retirementDate) {
+              text += `| Retirement Date | ${profile.retirementDate} |\n`;
+            }
+            text += `| Notes | ${profile.notes} |\n`;
+            return { content: [{ type: 'text', text }] };
+          }
+
+          // List all profiles
+          const registry = await loadAllProfiles();
+          let text = `# Azure Functions SKU Profiles\n\n`;
+          text += `| SKU | Display Name | Host Version | Bundle Version | Max Bundle | Status |\n`;
+          text += `|-----|-------------|-------------|---------------|-----------|--------|\n`;
+          for (const [key, p] of Object.entries(registry.profiles)) {
+            text += `| ${key} | ${p.displayName} | ${p.hostVersion} | ${p.extensionBundleVersion} | ${p.maxExtensionBundleVersion || 'n/a'} | ${p.status} |\n`;
+          }
+          text += `\n*Last updated: ${registry.updatedAt}*\n`;
+          return { content: [{ type: 'text', text }] };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    },
+    {
+      name: 'compare_skus',
+      description:
+        `Compare two Azure Functions SKU profiles side by side.\n\n` +
+        `Shows differences in host version, bundle version, status, and capabilities.\n` +
+        `Use this to understand deployment target differences.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          sku1: { type: 'string', description: 'First SKU name (e.g., flex)' },
+          sku2: { type: 'string', description: 'Second SKU name (e.g., windows-consumption)' },
+        },
+        required: ['sku1', 'sku2'],
+      },
+      async handler(args) {
+        try {
+          const [p1, p2] = await Promise.all([
+            resolveProfile(args.sku1),
+            resolveProfile(args.sku2),
+          ]);
+
+          let text = `# SKU Comparison: ${args.sku1} vs ${args.sku2}\n\n`;
+          text += `| Property | ${p1.displayName} | ${p2.displayName} |\n`;
+          text += `|----------|---|---|\n`;
+          text += `| Host Version | ${p1.hostVersion} | ${p2.hostVersion} |\n`;
+          text += `| Extension Bundle | ${p1.extensionBundleVersion} | ${p2.extensionBundleVersion} |\n`;
+          text += `| Max Bundle | ${p1.maxExtensionBundleVersion || 'n/a'} | ${p2.maxExtensionBundleVersion || 'n/a'} |\n`;
+          text += `| Status | ${p1.status} | ${p2.status} |\n`;
+
+          // Highlight differences
+          const diffs = [];
+          if (p1.hostVersion !== p2.hostVersion) {
+            diffs.push(`Host version differs: ${p1.hostVersion} vs ${p2.hostVersion}`);
+          }
+          if (p1.extensionBundleVersion !== p2.extensionBundleVersion) {
+            diffs.push(`Bundle version range differs: ${p1.extensionBundleVersion} vs ${p2.extensionBundleVersion}`);
+          }
+          if (p1.maxExtensionBundleVersion !== p2.maxExtensionBundleVersion) {
+            diffs.push(`Max bundle cap differs: ${p1.maxExtensionBundleVersion || 'n/a'} vs ${p2.maxExtensionBundleVersion || 'n/a'}`);
+          }
+          if (p1.status !== p2.status) {
+            diffs.push(`Status differs: ${p1.status} vs ${p2.status}`);
+          }
+
+          if (diffs.length > 0) {
+            text += `\n## Key Differences\n\n`;
+            for (const d of diffs) {
+              text += `- ⚠️ ${d}\n`;
+            }
+          } else {
+            text += `\n✅ These SKUs have identical configurations.\n`;
+          }
+
+          return { content: [{ type: 'text', text }] };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    },
+  ];
+}