@tpitre/story-ui 2.2.0 → 2.3.0

package/dist/mcp-server/routes/hybridStories.d.ts

@@ -0,0 +1,18 @@
+import { Request, Response } from 'express';
+/**
+ * Get all stories from both memory and file system
+ */
+export declare function getAllStories(req: Request, res: Response): void;
+/**
+ * Get a specific story by ID from memory or file system
+ */
+export declare function getStoryById(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * Get story content by ID
+ */
+export declare function getStoryContent(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * Delete a story by ID
+ */
+export declare function deleteStory(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+//# sourceMappingURL=hybridStories.d.ts.map

package/dist/mcp-server/routes/hybridStories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybridStories.d.ts","sourceRoot":"","sources":["../../../mcp-server/routes/hybridStories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAO5C;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QA6DxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDA0DvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDA0C1D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDA6CtD"}

package/dist/mcp-server/routes/mcpRemote.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP Remote HTTP Transport Routes
+ *
+ * Implements the SSE transport from the MCP SDK to enable
+ * remote connections from Claude Desktop and other MCP clients.
+ *
+ * This allows Story UI to be accessed from Claude Desktop without requiring
+ * a local process - useful for cloud deployments and shared Storybook instances.
+ *
+ * Uses the SSE transport available in MCP SDK v0.5.0
+ */
+export declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=mcpRemote.d.ts.map

package/dist/mcp-server/routes/mcpRemote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpRemote.d.ts","sourceRoot":"","sources":["../../../mcp-server/routes/mcpRemote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgCH,eAAO,MAAM,MAAM,4CAAW,CAAC;AAygB/B,eAAe,MAAM,CAAC"}

package/dist/mcp-server/routes/mcpRemote.js

@@ -0,0 +1,489 @@
+/**
+ * MCP Remote HTTP Transport Routes
+ *
+ * Implements the SSE transport from the MCP SDK to enable
+ * remote connections from Claude Desktop and other MCP clients.
+ *
+ * This allows Story UI to be accessed from Claude Desktop without requiring
+ * a local process - useful for cloud deployments and shared Storybook instances.
+ *
+ * Uses the SSE transport available in MCP SDK v0.5.0
+ */
+import { Router } from 'express';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import fs from 'fs';
+import path from 'path';
+import fetch from 'node-fetch';
+import { loadUserConfig } from '../../story-generator/configLoader.js';
+import { EnhancedComponentDiscovery } from '../../story-generator/enhancedComponentDiscovery.js';
+// Get package version
+const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+let PACKAGE_VERSION = '1.0.0';
+try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    PACKAGE_VERSION = packageJson.version;
+}
+catch {
+    // Use default version
+}
+// Get HTTP server port from environment variables
+const HTTP_PORT = process.env.VITE_STORY_UI_PORT || process.env.STORY_UI_HTTP_PORT || process.env.PORT || '4001';
+const HTTP_BASE_URL = `http://localhost:${HTTP_PORT}`;
+// Load configuration
+const config = loadUserConfig();
+export const router = Router();
+// Store SSE transports for session management
+const sseTransports = {};
+// Define available tools - same as the stdio server
+const TOOLS = [
+    {
+        name: 'test-connection',
+        description: 'Test if MCP connection is working',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'generate-story',
+        description: 'Generate a Storybook story from a natural language prompt',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: {
+                    type: 'string',
+                    description: 'The prompt describing what UI to generate',
+                },
+                chatId: {
+                    type: 'string',
+                    description: 'Optional chat ID for tracking',
+                },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'list-components',
+        description: 'List all available components that can be used in stories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                category: {
+                    type: 'string',
+                    description: 'Filter by category',
+                },
+            },
+        },
+    },
+    {
+        name: 'list-stories',
+        description: 'List all generated stories',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'get-story',
+        description: 'Get the content of a specific generated story',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                storyId: {
+                    type: 'string',
+                    description: 'The ID of the story to retrieve',
+                },
+            },
+            required: ['storyId'],
+        },
+    },
+    {
+        name: 'delete-story',
+        description: 'Delete a generated story',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                storyId: {
+                    type: 'string',
+                    description: 'The ID of the story to delete',
+                },
+            },
+            required: ['storyId'],
+        },
+    },
+    {
+        name: 'get-component-props',
+        description: 'Get detailed prop information for a specific component',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                componentName: {
+                    type: 'string',
+                    description: 'The name of the component',
+                },
+            },
+            required: ['componentName'],
+        },
+    },
+    {
+        name: 'update-story',
+        description: 'Update an existing Storybook story with modifications',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                storyId: {
+                    type: 'string',
+                    description: 'Optional: The ID of the story to update',
+                },
+                prompt: {
+                    type: 'string',
+                    description: 'Description of the changes to make to the story',
+                },
+            },
+            required: ['prompt'],
+        },
+    },
+];
+/**
+ * Create a configured MCP server instance with Story UI tools
+ */
+function createMcpServer() {
+    const server = new Server({
+        name: 'story-ui-remote',
+        version: PACKAGE_VERSION,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Register tool listing handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: TOOLS };
+    });
+    // Register tool execution handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case 'test-connection': {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'MCP remote connection is working! Story UI is connected via HTTP/SSE.',
+                            }],
+                    };
+                }
+                case 'generate-story': {
+                    const { prompt, chatId } = args;
+                    const response = await fetch(`${HTTP_BASE_URL}/mcp/generate-story`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ prompt, chatId }),
+                    });
+                    if (!response.ok) {
+                        const error = await response.text();
+                        throw new Error(`Failed to generate story: ${error}`);
+                    }
+                    const result = await response.json();
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Story generated successfully!\n\nTitle: ${result.title || 'Untitled'}\nStory ID: ${result.storyId || 'Unknown'}\nFile Name: ${result.fileName || 'Unknown'}\n\nStory Code:\n\`\`\`tsx\n${result.story || 'Story code not available'}\n\`\`\`\n\nOpen your Storybook instance to see the generated story.\n\nTo update this story later, use the Story ID: ${result.storyId}`,
+                            }],
+                    };
+                }
+                case 'list-components': {
+                    const { category } = args;
+                    const discovery = new EnhancedComponentDiscovery(config);
+                    const components = await discovery.discoverAll();
+                    let filteredComponents = components;
+                    if (category) {
+                        filteredComponents = components.filter(comp => comp.category?.toLowerCase() === category.toLowerCase());
+                    }
+                    const maxComponents = 50;
+                    const displayComponents = filteredComponents.slice(0, maxComponents);
+                    const componentList = displayComponents.map(comp => `- ${comp.name} (${comp.category || 'Uncategorized'})`).join('\n');
+                    const responseText = filteredComponents.length > maxComponents
+                        ? `Found ${filteredComponents.length} components (showing first ${maxComponents}):\n\n${componentList}\n\n...and ${filteredComponents.length - maxComponents} more components`
+                        : `Found ${filteredComponents.length} components:\n\n${componentList}`;
+                    return {
+                        content: [{ type: 'text', text: responseText }],
+                    };
+                }
+                case 'list-stories': {
+                    let fileStories = [];
+                    if (config.generatedStoriesPath && fs.existsSync(config.generatedStoriesPath)) {
+                        const files = fs.readdirSync(config.generatedStoriesPath);
+                        fileStories = files
+                            .filter(file => file.endsWith('.stories.tsx'))
+                            .map(file => {
+                            const hash = file.match(/-([a-f0-9]{8})\.stories\.tsx$/)?.[1] || '';
+                            const storyId = hash ? `story-${hash}` : file.replace('.stories.tsx', '');
+                            let title = file.replace('.stories.tsx', '').replace(/-/g, ' ');
+                            try {
+                                const filePath = path.join(config.generatedStoriesPath, file);
+                                const content = fs.readFileSync(filePath, 'utf-8');
+                                const titleMatch = content.match(/title:\s*['"]([^'"]+)['"]/);
+                                if (titleMatch) {
+                                    title = titleMatch[1].replace('Generated/', '');
+                                }
+                            }
+                            catch {
+                                // Use filename as fallback
+                            }
+                            return { id: storyId, fileName: file, title };
+                        });
+                    }
+                    if (fileStories.length === 0) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: 'No stories have been generated yet.\n\nGenerate your first story by describing what UI component you\'d like to create!',
+                                }],
+                        };
+                    }
+                    let responseText = `**Available stories (${fileStories.length}):**\n`;
+                    fileStories.forEach(story => {
+                        responseText += `\n- ${story.title}\n  ID: ${story.id}\n  File: ${story.fileName}\n`;
+                    });
+                    return { content: [{ type: 'text', text: responseText }] };
+                }
+                case 'get-story': {
+                    const { storyId } = args;
+                    const response = await fetch(`${HTTP_BASE_URL}/mcp/stories/${storyId}`);
+                    if (!response.ok) {
+                        throw new Error(`Story with ID ${storyId} not found`);
+                    }
+                    const story = await response.json();
+                    const contentResponse = await fetch(`${HTTP_BASE_URL}/mcp/stories/${storyId}/content`);
+                    const content = contentResponse.ok ? await contentResponse.text() : story.content || story.story || 'Content not available';
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ${story.title || story.fileName || 'Untitled'}\n\nID: ${story.id || story.storyId || storyId}\n\n## Story Code:\n\`\`\`tsx\n${content}\n\`\`\``,
+                            }],
+                    };
+                }
+                case 'delete-story': {
+                    const { storyId } = args;
+                    if (config.generatedStoriesPath && fs.existsSync(config.generatedStoriesPath)) {
+                        const files = fs.readdirSync(config.generatedStoriesPath);
+                        const hashMatch = storyId.match(/^story-([a-f0-9]{8})$/);
+                        const hash = hashMatch ? hashMatch[1] : null;
+                        const matchingFile = files.find(file => {
+                            if (hash && file.includes(`-${hash}.stories.tsx`))
+                                return true;
+                            if (file === `${storyId}.stories.tsx`)
+                                return true;
+                            if (file === storyId)
+                                return true;
+                            return false;
+                        });
+                        if (matchingFile) {
+                            const filePath = path.join(config.generatedStoriesPath, matchingFile);
+                            fs.unlinkSync(filePath);
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: `Story "${matchingFile}" has been deleted successfully.`,
+                                    }],
+                            };
+                        }
+                    }
+                    throw new Error(`Story not found in file system`);
+                }
+                case 'get-component-props': {
+                    const { componentName } = args;
+                    const response = await fetch(`${HTTP_BASE_URL}/mcp/props?component=${encodeURIComponent(componentName)}`);
+                    if (!response.ok) {
+                        throw new Error(`Failed to get component props: ${response.statusText}`);
+                    }
+                    const props = await response.json();
+                    if (!props || Object.keys(props).length === 0) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `No prop information found for component ${componentName}.`,
+                                }],
+                        };
+                    }
+                    const propsList = Object.entries(props).map(([propName, info]) => `- ${propName}: ${info.type} ${info.required ? '(required)' : '(optional)'}${info.description ? ` - ${info.description}` : ''}`).join('\n');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Props for ${componentName}:\n\n${propsList}`,
+                            }],
+                    };
+                }
+                case 'update-story': {
+                    let { storyId, prompt } = args;
+                    // Find the story to update if no ID provided
+                    if (!storyId && config.generatedStoriesPath && fs.existsSync(config.generatedStoriesPath)) {
+                        const files = fs.readdirSync(config.generatedStoriesPath)
+                            .filter(f => f.endsWith('.stories.tsx'))
+                            .sort((a, b) => {
+                            const statA = fs.statSync(path.join(config.generatedStoriesPath, a));
+                            const statB = fs.statSync(path.join(config.generatedStoriesPath, b));
+                            return statB.mtime.getTime() - statA.mtime.getTime();
+                        });
+                        if (files.length > 0) {
+                            const hash = files[0].match(/-([a-f0-9]{8})\.stories\.tsx$/)?.[1];
+                            storyId = hash ? `story-${hash}` : files[0].replace('.stories.tsx', '');
+                        }
+                    }
+                    if (!storyId) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: 'No story found to update. Please generate a story first or specify which story you\'d like to update.',
+                                }],
+                            isError: true,
+                        };
+                    }
+                    // Get existing story content
+                    let existingCode = '';
+                    let storyMetadata = {};
+                    if (config.generatedStoriesPath && fs.existsSync(config.generatedStoriesPath)) {
+                        const files = fs.readdirSync(config.generatedStoriesPath);
+                        const hashMatch = storyId.match(/^story-([a-f0-9]{8})$/);
+                        const hash = hashMatch ? hashMatch[1] : null;
+                        const matchingFile = files.find(file => {
+                            if (hash && file.includes(`-${hash}.stories.tsx`))
+                                return true;
+                            return false;
+                        });
+                        if (matchingFile) {
+                            const filePath = path.join(config.generatedStoriesPath, matchingFile);
+                            existingCode = fs.readFileSync(filePath, 'utf-8');
+                            const titleMatch = existingCode.match(/title:\s*['"]([^'"]+)['"]/);
+                            storyMetadata = {
+                                fileName: matchingFile,
+                                title: titleMatch ? titleMatch[1] : 'Untitled',
+                            };
+                        }
+                    }
+                    const conversation = [
+                        { role: 'user', content: storyMetadata.prompt || 'Generate a story' },
+                        { role: 'assistant', content: existingCode },
+                        { role: 'user', content: prompt },
+                    ];
+                    const response = await fetch(`${HTTP_BASE_URL}/mcp/generate-story`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            prompt,
+                            fileName: storyMetadata.fileName || storyId,
+                            conversation,
+                            isUpdate: true,
+                            originalTitle: storyMetadata.title,
+                            storyId,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const error = await response.text();
+                        throw new Error(`Failed to update story: ${error}`);
+                    }
+                    const result = await response.json();
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Story updated successfully!\n\nTitle: ${result.title || 'Untitled'}\nID: ${result.storyId || result.fileName || 'Unknown'}\n\nUpdated Story Code:\n\`\`\`tsx\n${result.story || 'Story code not available'}\n\`\`\`\n\nThe story has been updated in your Storybook instance.`,
+                            }],
+                    };
+                }
+                default:
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Unknown tool: ${name}`,
+                            }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+/**
+ * SSE endpoint for establishing the MCP connection
+ * GET /mcp-remote/sse
+ */
+router.get('/sse', async (req, res) => {
+    try {
+        console.log('[MCP Remote] New SSE connection request');
+        // Create SSE transport
+        const transport = new SSEServerTransport('/mcp-remote/messages', res);
+        sseTransports[transport.sessionId] = transport;
+        console.log(`[MCP Remote] SSE session created: ${transport.sessionId}`);
+        // Handle connection close
+        res.on('close', () => {
+            delete sseTransports[transport.sessionId];
+            console.log(`[MCP Remote] SSE session closed: ${transport.sessionId}`);
+        });
+        // Create and connect the MCP server
+        // Note: server.connect() calls transport.start() internally
+        const server = createMcpServer();
+        await server.connect(transport);
+    }
+    catch (error) {
+        console.error('[MCP Remote] Error creating SSE session:', error);
+        if (!res.headersSent) {
+            res.status(500).send('Failed to create SSE session');
+        }
+    }
+});
+/**
+ * Message endpoint for SSE transport
+ * POST /mcp-remote/messages
+ */
+router.post('/messages', async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+        res.status(400).json({ error: 'sessionId query parameter is required' });
+        return;
+    }
+    const transport = sseTransports[sessionId];
+    if (!transport) {
+        res.status(400).json({ error: `No transport found for sessionId: ${sessionId}` });
+        return;
+    }
+    try {
+        // Use the raw node request/response for handlePostMessage
+        await transport.handlePostMessage(req, res);
+    }
+    catch (error) {
+        console.error('[MCP Remote] Error handling message:', error);
+        if (!res.headersSent) {
+            res.status(500).json({ error: 'Failed to handle message' });
+        }
+    }
+});
+/**
+ * Health check endpoint for the MCP remote service
+ * GET /mcp-remote/health
+ */
+router.get('/health', (req, res) => {
+    res.json({
+        status: 'ok',
+        service: 'story-ui-mcp-remote',
+        version: PACKAGE_VERSION,
+        transport: 'SSE',
+        activeSessions: Object.keys(sseTransports).length,
+        endpoints: {
+            sse: '/mcp-remote/sse',
+            messages: '/mcp-remote/messages',
+        },
+    });
+});
+export default router;

package/dist/mcp-server/routes/memoryStories.d.ts

@@ -0,0 +1,26 @@
+import { Request, Response } from 'express';
+/**
+ * Get all stories metadata
+ */
+export declare function getStoriesMetadata(req: Request, res: Response): void;
+/**
+ * Get a specific story by ID
+ */
+export declare function getStoryById(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * Get story content for Storybook integration
+ */
+export declare function getStoryContent(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * Delete a story by ID
+ */
+export declare function deleteStory(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * Clear all stories
+ */
+export declare function clearAllStories(req: Request, res: Response): void;
+/**
+ * Get memory usage statistics
+ */
+export declare function getMemoryStats(req: Request, res: Response): void;
+//# sourceMappingURL=memoryStories.d.ts.map

package/dist/mcp-server/routes/memoryStories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryStories.d.ts","sourceRoot":"","sources":["../../../mcp-server/routes/memoryStories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI5C;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAiB7D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDAwBvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDAuB1D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDAwBtD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAgB1D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAoBzD"}

package/dist/mcp-server/routes/providers.d.ts

@@ -0,0 +1,89 @@
+/**
+ * LLM Provider Management Routes
+ *
+ * API endpoints for managing LLM providers, API keys, and model selection.
+ */
+import { Request, Response } from 'express';
+/**
+ * GET /mcp/providers
+ * Returns list of available providers and their configuration status
+ */
+export declare function getProviders(req: Request, res: Response): void;
+/**
+ * GET /mcp/providers/models
+ * Returns all available models across all providers
+ */
+export declare function getModels(req: Request, res: Response): void;
+/**
+ * POST /mcp/providers/configure
+ * Configure a provider with API key and optional model
+ *
+ * Body: {
+ *   provider: 'claude' | 'openai' | 'gemini',
+ *   apiKey: string,
+ *   model?: string,
+ *   setAsDefault?: boolean
+ * }
+ */
+export declare function configureProviderRoute(req: Request, res: Response): Promise<Response<any, Record<string, any>> | undefined>;
+/**
+ * POST /mcp/providers/validate
+ * Validate an API key for a provider without saving it
+ *
+ * Body: {
+ *   provider: 'claude' | 'openai' | 'gemini',
+ *   apiKey: string
+ * }
+ */
+export declare function validateApiKey(req: Request, res: Response): Promise<Response<any, Record<string, any>> | undefined>;
+/**
+ * POST /mcp/providers/default
+ * Set the default provider
+ *
+ * Body: {
+ *   provider: 'claude' | 'openai' | 'gemini'
+ * }
+ */
+export declare function setDefaultProvider(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * POST /mcp/providers/model
+ * Set the model for a provider
+ *
+ * Body: {
+ *   provider?: 'claude' | 'openai' | 'gemini',  // defaults to current provider
+ *   model: string
+ * }
+ */
+export declare function setModel(req: Request, res: Response): Response<any, Record<string, any>> | undefined;
+/**
+ * GET /mcp/providers/settings
+ * Get UI settings configuration with available providers/models
+ *
+ * This endpoint is designed for non-technical users to select
+ * from pre-approved providers and models configured by DevOps.
+ *
+ * Query params:
+ *   provider?: current selected provider
+ *   model?: current selected model
+ */
+export declare function getUISettings(req: Request, res: Response): void;
+/**
+ * POST /mcp/providers/settings
+ * Apply user's provider/model selection
+ *
+ * Body: {
+ *   provider?: 'claude' | 'openai' | 'gemini',
+ *   model?: string
+ * }
+ *
+ * Returns effective settings (may fall back to defaults if invalid)
+ */
+export declare function applyUISettings(req: Request, res: Response): void;
+/**
+ * GET /mcp/providers/config
+ * Get current environment configuration (for admin/debugging)
+ *
+ * This reveals which restrictions are in place.
+ */
+export declare function getSettingsConfig(req: Request, res: Response): void;
+//# sourceMappingURL=providers.d.ts.map

package/dist/mcp-server/routes/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../mcp-server/routes/providers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAoB5C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAqBvD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QA0BpD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,2DAkDvE;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,2DAkC/D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDAwC7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,kDAwDnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAkBxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAyC1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,QAuB5D"}