@vfarcic/dot-ai 1.10.2 → 1.12.0

package/dist/core/mcp-client-manager.js

@@ -0,0 +1,362 @@
+"use strict";
+/**
+ * MCP Client Manager for dot-ai MCP Server Integration
+ *
+ * Connects to external MCP servers running in the cluster, discovers their tools,
+ * and makes them available to dot-ai operations (remediate, operate, query) via
+ * the attachTo routing mechanism.
+ *
+ * PRD #358: MCP Server Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClientManager = void 0;
+const node_fs_1 = require("node:fs");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const mcp_client_types_1 = require("./mcp-client-types");
+/** Path for MCP servers config file (mounted from ConfigMap in K8s) */
+const MCP_SERVERS_CONFIG_PATH = '/etc/dot-ai-mcp/mcp-servers.json';
+/** Separator used to namespace MCP tools: {serverName}__{toolName} */
+const TOOL_NAME_SEPARATOR = '__';
+/** Default timeout for MCP requests in milliseconds */
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Manages MCP server connections, tool discovery, and tool routing.
+ *
+ * Follows the same structural patterns as PluginManager but uses
+ * the MCP SDK (Client + StreamableHTTPClientTransport) instead of HTTP REST.
+ */
+class McpClientManager {
+    logger;
+    /** MCP SDK Client instances keyed by server name */
+    clients = new Map();
+    /** Transport instances keyed by server name (needed for cleanup) */
+    transports = new Map();
+    /** Discovered server metadata keyed by server name */
+    discoveredServers = new Map();
+    /** Maps namespaced tool name → server name for routing */
+    toolToServer = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Parse MCP server configuration from file.
+     *
+     * Reads from /etc/dot-ai-mcp/mcp-servers.json (mounted from ConfigMap in K8s).
+     * Returns empty array if file doesn't exist (MCP servers only work in-cluster).
+     * Throws on invalid JSON or malformed configuration.
+     */
+    static parseMcpServerConfig() {
+        if (!(0, node_fs_1.existsSync)(MCP_SERVERS_CONFIG_PATH)) {
+            return [];
+        }
+        let content;
+        try {
+            content = (0, node_fs_1.readFileSync)(MCP_SERVERS_CONFIG_PATH, 'utf-8');
+        }
+        catch (err) {
+            throw new Error(`Failed to read MCP server config at ${MCP_SERVERS_CONFIG_PATH}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`Invalid JSON in MCP server config at ${MCP_SERVERS_CONFIG_PATH}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error(`MCP server config at ${MCP_SERVERS_CONFIG_PATH} must be an array, got ${typeof parsed}`);
+        }
+        const validOperations = ['remediate', 'operate', 'query'];
+        return parsed.map((s, index) => {
+            if (!s || typeof s !== 'object') {
+                throw new Error(`MCP server at index ${index} must be an object`);
+            }
+            if (!s.endpoint || typeof s.endpoint !== 'string') {
+                throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) is missing required 'endpoint' field`);
+            }
+            if (!Array.isArray(s.attachTo) || s.attachTo.length === 0) {
+                throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) must have a non-empty 'attachTo' array`);
+            }
+            for (const op of s.attachTo) {
+                if (!validOperations.includes(op)) {
+                    throw new Error(`MCP server at index ${index} (${s.name || 'unnamed'}) has invalid attachTo value '${op}'. Must be one of: ${validOperations.join(', ')}`);
+                }
+            }
+            return {
+                name: s.name || `mcp-server-${index}`,
+                endpoint: s.endpoint,
+                attachTo: s.attachTo,
+                timeout: s.timeout,
+            };
+        });
+    }
+    /**
+     * Discover all configured MCP servers.
+     *
+     * Connects to each server, performs MCP handshake, and discovers available tools.
+     * All servers must connect successfully — any failure throws McpDiscoveryError.
+     */
+    async discoverMcpServers(configs) {
+        if (configs.length === 0) {
+            this.logger.debug('No MCP servers configured for discovery');
+            return;
+        }
+        this.logger.info('Starting MCP server discovery', {
+            serverCount: configs.length,
+            servers: configs.map(c => c.name),
+        });
+        const results = await Promise.allSettled(configs.map(config => this.connectAndDiscover(config)));
+        const failed = [];
+        results.forEach((result, index) => {
+            const config = configs[index];
+            if (result.status === 'rejected') {
+                const error = result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason);
+                failed.push({ name: config.name, error });
+            }
+        });
+        if (failed.length > 0) {
+            throw new mcp_client_types_1.McpDiscoveryError(`MCP server discovery failed: ${failed.map(f => `${f.name} (${f.error})`).join(', ')}`, failed);
+        }
+        this.logger.info('MCP server discovery complete', {
+            discovered: this.discoveredServers.size,
+            totalTools: this.toolToServer.size,
+        });
+    }
+    /**
+     * Connect to a single MCP server and discover its tools.
+     */
+    async connectAndDiscover(config) {
+        const timeout = config.timeout || DEFAULT_TIMEOUT_MS;
+        this.logger.debug('Connecting to MCP server', {
+            name: config.name,
+            endpoint: config.endpoint,
+            attachTo: config.attachTo,
+        });
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(config.endpoint), {
+            reconnectionOptions: {
+                maxReconnectionDelay: 30_000,
+                initialReconnectionDelay: 1_000,
+                reconnectionDelayGrowFactor: 1.5,
+                maxRetries: 2,
+            },
+        });
+        const client = new index_js_1.Client({ name: 'dot-ai', version: '1.0.0' }, { capabilities: {} });
+        // Connect with timeout
+        const connectPromise = client.connect(transport);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Connection timed out after ${timeout}ms`)), timeout));
+        try {
+            await Promise.race([connectPromise, timeoutPromise]);
+        }
+        catch (err) {
+            // Clean up transport on failure
+            try {
+                await transport.close();
+            }
+            catch { /* ignore cleanup errors */ }
+            throw new Error(`Failed to connect to MCP server '${config.name}' at ${config.endpoint}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Discover tools
+        let tools;
+        try {
+            const result = await client.listTools();
+            tools = result.tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: {
+                    type: t.inputSchema.type,
+                    properties: t.inputSchema.properties,
+                    required: t.inputSchema.required,
+                },
+            }));
+        }
+        catch (err) {
+            try {
+                await transport.close();
+            }
+            catch { /* ignore cleanup errors */ }
+            throw new Error(`Failed to list tools from MCP server '${config.name}': ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Store client and transport
+        this.clients.set(config.name, client);
+        this.transports.set(config.name, transport);
+        // Store discovered server metadata
+        this.discoveredServers.set(config.name, {
+            name: config.name,
+            endpoint: config.endpoint,
+            attachTo: config.attachTo,
+            version: client.getServerVersion()?.version,
+            tools,
+            discoveredAt: new Date(),
+        });
+        // Map namespaced tools to server
+        for (const tool of tools) {
+            const namespacedName = `${config.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+            if (this.toolToServer.has(namespacedName)) {
+                this.logger.warn('Namespaced tool name conflict - overwriting', {
+                    tool: namespacedName,
+                    existingServer: this.toolToServer.get(namespacedName),
+                    newServer: config.name,
+                });
+            }
+            this.toolToServer.set(namespacedName, config.name);
+        }
+        this.logger.info('MCP server discovered', {
+            name: config.name,
+            version: client.getServerVersion()?.version,
+            tools: tools.map(t => t.name),
+            namespacedTools: tools.map(t => `${config.name}${TOOL_NAME_SEPARATOR}${t.name}`),
+        });
+    }
+    /**
+     * Get tools available for a specific dot-ai operation, filtered by attachTo.
+     *
+     * Returns tools as AITool[] with namespaced names ({serverName}__{toolName}).
+     */
+    getToolsForOperation(operation) {
+        const tools = [];
+        for (const server of this.discoveredServers.values()) {
+            if (!server.attachTo.includes(operation)) {
+                continue;
+            }
+            for (const tool of server.tools) {
+                const namespacedName = `${server.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+                // Only include if this server owns the routing
+                if (this.toolToServer.get(namespacedName) === server.name) {
+                    tools.push(this.convertToAITool(server.name, tool));
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Get all discovered tools across all servers.
+     */
+    getAllDiscoveredTools() {
+        const tools = [];
+        for (const server of this.discoveredServers.values()) {
+            for (const tool of server.tools) {
+                const namespacedName = `${server.name}${TOOL_NAME_SEPARATOR}${tool.name}`;
+                if (this.toolToServer.get(namespacedName) === server.name) {
+                    tools.push(this.convertToAITool(server.name, tool));
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Check if a tool name belongs to an MCP server (is namespaced).
+     */
+    isMcpTool(toolName) {
+        return this.toolToServer.has(toolName);
+    }
+    /**
+     * Create a ToolExecutor that routes MCP tools to their servers.
+     *
+     * Returns a function compatible with toolLoop's toolExecutor parameter.
+     * MCP tools (namespaced) are routed to their MCP servers; non-MCP tools
+     * are routed to the optional fallback executor.
+     */
+    createToolExecutor(fallbackExecutor) {
+        return async (toolName, input) => {
+            if (this.isMcpTool(toolName)) {
+                this.logger.debug('Routing tool to MCP server', {
+                    tool: toolName,
+                    server: this.toolToServer.get(toolName),
+                });
+                try {
+                    const serverName = this.toolToServer.get(toolName);
+                    const originalToolName = toolName.substring(serverName.length + TOOL_NAME_SEPARATOR.length);
+                    const client = this.clients.get(serverName);
+                    if (!client) {
+                        return `Error: MCP server '${serverName}' is not connected`;
+                    }
+                    const result = await client.callTool({
+                        name: originalToolName,
+                        arguments: input,
+                    });
+                    // Extract text content from MCP response
+                    const contentArray = result.content;
+                    if (result.isError) {
+                        const errorText = contentArray
+                            ?.filter(c => c.type === 'text')
+                            .map(c => c.text)
+                            .join('\n') || 'Unknown MCP tool error';
+                        return `Error: ${errorText}`;
+                    }
+                    // Return text content for AI consumption
+                    const textContent = contentArray
+                        ?.filter(c => c.type === 'text')
+                        .map(c => c.text)
+                        .join('\n');
+                    return textContent || '';
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.logger.error('MCP tool invocation failed', new Error(message), { tool: toolName, server: this.toolToServer.get(toolName) });
+                    return `Error: ${message}`;
+                }
+            }
+            // Fall back to provided executor for non-MCP tools
+            if (fallbackExecutor) {
+                return fallbackExecutor(toolName, input);
+            }
+            return `Error: Tool '${toolName}' not found in MCP servers or fallback executor`;
+        };
+    }
+    /**
+     * Get statistics about MCP server connections.
+     */
+    getStats() {
+        return {
+            serverCount: this.discoveredServers.size,
+            toolCount: this.toolToServer.size,
+            servers: Array.from(this.discoveredServers.keys()),
+        };
+    }
+    /**
+     * Get discovered server metadata.
+     */
+    getDiscoveredServers() {
+        return Array.from(this.discoveredServers.values());
+    }
+    /**
+     * Close all MCP server connections.
+     */
+    async close() {
+        for (const [name, transport] of this.transports.entries()) {
+            try {
+                await transport.close();
+                this.logger.debug('Closed MCP server connection', { name });
+            }
+            catch (err) {
+                this.logger.warn('Error closing MCP server connection', {
+                    name,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        this.clients.clear();
+        this.transports.clear();
+        this.discoveredServers.clear();
+        this.toolToServer.clear();
+    }
+    /**
+     * Convert an MCP tool definition to AITool format with namespaced name.
+     */
+    convertToAITool(serverName, tool) {
+        const namespacedName = `${serverName}${TOOL_NAME_SEPARATOR}${tool.name}`;
+        return {
+            name: namespacedName,
+            description: `[${serverName}] ${tool.description || tool.name}`,
+            inputSchema: {
+                type: 'object',
+                properties: tool.inputSchema.properties || {},
+                required: tool.inputSchema.required,
+            },
+        };
+    }
+}
+exports.McpClientManager = McpClientManager;

package/dist/core/mcp-client-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * MCP Client Registry - Unified MCP Server Tool Access
+ *
+ * PRD #358: Provides a single, consistent way to access MCP server tools
+ * from anywhere in the codebase (remediate, operate, query).
+ *
+ * Usage:
+ *   // At startup (src/mcp/server.ts):
+ *   initializeMcpClientRegistry(mcpClientManager);
+ *
+ *   // Anywhere in the codebase:
+ *   if (isMcpClientInitialized()) {
+ *     const tools = getMcpClientManager()!.getToolsForOperation('remediate');
+ *   }
+ */
+import type { McpClientManager } from './mcp-client-manager';
+/**
+ * Initialize the MCP client registry with a McpClientManager instance.
+ * Must be called once at startup after MCP servers are discovered.
+ */
+export declare function initializeMcpClientRegistry(manager: McpClientManager): void;
+/**
+ * Get the McpClientManager instance.
+ * Returns null if not initialized.
+ */
+export declare function getMcpClientManager(): McpClientManager | null;
+/**
+ * Check if the MCP client registry is initialized.
+ */
+export declare function isMcpClientInitialized(): boolean;
+/**
+ * Reset the MCP client registry (for testing only).
+ * @internal
+ */
+export declare function resetMcpClientRegistry(): void;
+//# sourceMappingURL=mcp-client-registry.d.ts.map

package/dist/core/mcp-client-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client-registry.d.ts","sourceRoot":"","sources":["../../src/core/mcp-client-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAO7D;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAE3E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/dist/core/mcp-client-registry.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * MCP Client Registry - Unified MCP Server Tool Access
+ *
+ * PRD #358: Provides a single, consistent way to access MCP server tools
+ * from anywhere in the codebase (remediate, operate, query).
+ *
+ * Usage:
+ *   // At startup (src/mcp/server.ts):
+ *   initializeMcpClientRegistry(mcpClientManager);
+ *
+ *   // Anywhere in the codebase:
+ *   if (isMcpClientInitialized()) {
+ *     const tools = getMcpClientManager()!.getToolsForOperation('remediate');
+ *   }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeMcpClientRegistry = initializeMcpClientRegistry;
+exports.getMcpClientManager = getMcpClientManager;
+exports.isMcpClientInitialized = isMcpClientInitialized;
+exports.resetMcpClientRegistry = resetMcpClientRegistry;
+/**
+ * Global MCP client manager instance (set once at startup)
+ */
+let mcpClientManager = null;
+/**
+ * Initialize the MCP client registry with a McpClientManager instance.
+ * Must be called once at startup after MCP servers are discovered.
+ */
+function initializeMcpClientRegistry(manager) {
+    mcpClientManager = manager;
+}
+/**
+ * Get the McpClientManager instance.
+ * Returns null if not initialized.
+ */
+function getMcpClientManager() {
+    return mcpClientManager;
+}
+/**
+ * Check if the MCP client registry is initialized.
+ */
+function isMcpClientInitialized() {
+    return mcpClientManager !== null;
+}
+/**
+ * Reset the MCP client registry (for testing only).
+ * @internal
+ */
+function resetMcpClientRegistry() {
+    mcpClientManager = null;
+}

package/dist/core/mcp-client-types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * MCP Client Types for dot-ai MCP Server Integration
+ *
+ * Defines the interface contract for connecting to external MCP servers.
+ * MCP servers provide additional tools (e.g., Prometheus metrics, tracing)
+ * that augment dot-ai's built-in kubectl/helm tools.
+ *
+ * PRD #358: MCP Server Integration
+ */
+/**
+ * Valid dot-ai operations that MCP servers can attach to
+ */
+export type McpAttachableOperation = 'remediate' | 'operate' | 'query';
+/**
+ * Configuration for an MCP server connection.
+ * Loaded from /etc/dot-ai-mcp/mcp-servers.json (mounted via Helm ConfigMap).
+ */
+export interface McpServerConfig {
+    /** Unique server name (e.g., "prometheus", "jaeger") */
+    name: string;
+    /** MCP server HTTP endpoint URL (e.g., "http://prometheus-mcp.monitoring.svc:3000") */
+    endpoint: string;
+    /** Which dot-ai operations this server's tools should be available to */
+    attachTo: McpAttachableOperation[];
+    /** Optional timeout in milliseconds for MCP requests (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Tool definition discovered from an MCP server via client.listTools()
+ */
+export interface McpToolDefinition {
+    /** Original tool name from MCP server */
+    name: string;
+    /** Tool description */
+    description?: string;
+    /** JSON Schema for tool input */
+    inputSchema: {
+        type: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * MCP server metadata after successful discovery
+ */
+export interface DiscoveredMcpServer {
+    /** Server name from config */
+    name: string;
+    /** Server endpoint URL */
+    endpoint: string;
+    /** Which operations this server is attached to */
+    attachTo: McpAttachableOperation[];
+    /** Server version from MCP protocol (if available) */
+    version?: string;
+    /** Tools provided by this server */
+    tools: McpToolDefinition[];
+    /** Discovery timestamp */
+    discoveredAt: Date;
+}
+/**
+ * Stats about MCP server connections
+ */
+export interface McpServerStats {
+    /** Number of connected servers */
+    serverCount: number;
+    /** Total number of discovered tools across all servers */
+    toolCount: number;
+    /** Names of connected servers */
+    servers: string[];
+}
+/**
+ * Error thrown when MCP server discovery fails
+ */
+export declare class McpDiscoveryError extends Error {
+    readonly failedServers: Array<{
+        name: string;
+        error: string;
+    }>;
+    constructor(message: string, failedServers: Array<{
+        name: string;
+        error: string;
+    }>);
+}
+//# sourceMappingURL=mcp-client-types.d.ts.map

package/dist/core/mcp-client-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client-types.d.ts","sourceRoot":"","sources":["../../src/core/mcp-client-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvE;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,0BAA0B;IAC1B,YAAY,EAAE,IAAI,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;gBADrE,OAAO,EAAE,MAAM,EACC,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAKxE"}

package/dist/core/mcp-client-types.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * MCP Client Types for dot-ai MCP Server Integration
+ *
+ * Defines the interface contract for connecting to external MCP servers.
+ * MCP servers provide additional tools (e.g., Prometheus metrics, tracing)
+ * that augment dot-ai's built-in kubectl/helm tools.
+ *
+ * PRD #358: MCP Server Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpDiscoveryError = void 0;
+/**
+ * Error thrown when MCP server discovery fails
+ */
+class McpDiscoveryError extends Error {
+    failedServers;
+    constructor(message, failedServers) {
+        super(message);
+        this.failedServers = failedServers;
+        this.name = 'McpDiscoveryError';
+    }
+}
+exports.McpDiscoveryError = McpDiscoveryError;

package/dist/core/model-config.d.ts

@@ -12,6 +12,7 @@ export declare const CURRENT_MODELS: {
     readonly google: "gemini-3.1-pro-preview";
     readonly google_flash: "gemini-3-flash-preview";
     readonly kimi: "kimi-k2.5";
+    readonly alibaba: "qwen3.5-plus";
     readonly xai: "grok-4";
     readonly host: "host";
     readonly openrouter: "anthropic/claude-haiku-4.5";

package/dist/core/model-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-config.d.ts","sourceRoot":"","sources":["../../src/core/model-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAajB,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,OAAO,cAAc,GAAG,MAAM,CAE7E"}
+{"version":3,"file":"model-config.d.ts","sourceRoot":"","sources":["../../src/core/model-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;CAcjB,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,OAAO,cAAc,GAAG,MAAM,CAE7E"}

package/dist/core/model-config.js

@@ -16,6 +16,7 @@ exports.CURRENT_MODELS = {
     google: 'gemini-3.1-pro-preview',
     google_flash: 'gemini-3-flash-preview', // PRD #294: Gemini 3 Flash - faster/cheaper variant with same 1M context
     kimi: 'kimi-k2.5', // PRD #353: Moonshot AI Kimi K2.5 - single model with thinking by default, 256K context
+    alibaba: 'qwen3.5-plus', // PRD #382: Alibaba Qwen 3.5 Plus - 262K context, 201 languages, MoE architecture
     xai: 'grok-4',
     host: 'host', // Delegates generation to the client via MCP Sampling
     openrouter: 'anthropic/claude-haiku-4.5', // PRD #194: OpenRouter default model (overridden by AI_MODEL env var)

package/dist/core/providers/vercel-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel-provider.d.ts","sourceRoot":"","sources":["../../../src/core/providers/vercel-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EACL,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACd,MAAM,0BAA0B,CAAC;AA4DlC,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,aAAa,CAAiB;gBAE1B,MAAM,EAAE,gBAAgB;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,eAAe;IAwFvB,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,OAAO;IAIxB,OAAO,CAAC,iBAAiB;IAyBnB,WAAW,CACf,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,MAAkB,EAC7B,iBAAiB,CAAC,EAAE;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,UAAU,CAAC;IAsJtB;;;;;;;;;;;;OAYG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA6b/D"}
+{"version":3,"file":"vercel-provider.d.ts","sourceRoot":"","sources":["../../../src/core/providers/vercel-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,OAAO,EACL,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACd,MAAM,0BAA0B,CAAC;AA4DlC,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,aAAa,CAAiB;gBAE1B,MAAM,EAAE,gBAAgB;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,eAAe;IA4FvB,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,OAAO;IAIxB,OAAO,CAAC,iBAAiB;IAyBnB,WAAW,CACf,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,MAAkB,EAC7B,iBAAiB,CAAC,EAAE;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,UAAU,CAAC;IAsJtB;;;;;;;;;;;;OAYG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA6b/D"}

package/dist/core/providers/vercel-provider.js

@@ -13,6 +13,7 @@ const openai_compatible_1 = require("@ai-sdk/openai-compatible");
 const google_1 = require("@ai-sdk/google");
 const anthropic_1 = require("@ai-sdk/anthropic");
 const xai_1 = require("@ai-sdk/xai");
+const alibaba_1 = require("@ai-sdk/alibaba");
 const amazon_bedrock_1 = require("@ai-sdk/amazon-bedrock");
 const ai_sdk_provider_1 = require("@openrouter/ai-sdk-provider");
 const constants_1 = require("../constants");
@@ -75,6 +76,10 @@ class VercelProvider {
                 case 'xai':
                     provider = (0, xai_1.createXai)({ apiKey: this.apiKey });
                     break;
+                case 'alibaba':
+                    // PRD #382: Alibaba Qwen 3.5 Plus - uses @ai-sdk/alibaba dedicated SDK
+                    provider = (0, alibaba_1.createAlibaba)({ apiKey: this.apiKey });
+                    break;
                 case 'kimi':
                     // PRD #353: Moonshot AI Kimi K2.5 - uses @ai-sdk/openai-compatible for proper
                     // reasoning_content preservation in multi-turn tool calling

package/dist/interfaces/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/interfaces/mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAwEtC,OAAO,EAAgB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAcvD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAmBD,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,UAAU,CAAC,CAAkC;IACrD,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,cAAc,CAAC,CAAiC;IACxD,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAA6B;IAC9C,OAAO,CAAC,aAAa,CAAC,CAAqB;IAC3C,OAAO,CAAC,SAAS,CAAC,CAAM;gBAEZ,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe;IA6BjD;;;OAGG;IACH,gBAAgB,IAAI,aAAa,GAAG,SAAS;IAQ7C;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2CvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkKnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;;;OAIG;YACW,mBAAmB;IA6CjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,iBAAiB;IAInB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAed,kBAAkB;YAuQlB,gBAAgB;IAexB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC3B,OAAO,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/interfaces/mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AA8EtC,OAAO,EAAgB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAcvD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAmBD,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,UAAU,CAAC,CAAkC;IACrD,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,cAAc,CAAC,CAAiC;IACxD,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAA6B;IAC9C,OAAO,CAAC,aAAa,CAAC,CAAqB;IAC3C,OAAO,CAAC,SAAS,CAAC,CAAM;gBAEZ,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe;IA6BjD;;;OAGG;IACH,gBAAgB,IAAI,aAAa,GAAG,SAAS;IAQ7C;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2CvB;;OAEG;IACH,OAAO,CAAC,WAAW;IA8KnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;;;OAIG;YACW,mBAAmB;IA6CjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,iBAAiB;IAInB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAed,kBAAkB;YAuQlB,gBAAgB;IAexB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC3B,OAAO,IAAI,OAAO;CAGnB"}

package/dist/interfaces/mcp.js

@@ -24,6 +24,7 @@ const operate_1 = require("../tools/operate");
 const project_setup_1 = require("../tools/project-setup");
 const query_1 = require("../tools/query");
 const manage_knowledge_1 = require("../tools/manage-knowledge");
+const impact_analysis_1 = require("../tools/impact-analysis");
 const prompts_1 = require("../tools/prompts");
 const rest_registry_1 = require("./rest-registry");
 const rest_api_1 = require("./rest-api");
@@ -264,6 +265,18 @@ class MCPServer {
                 category: 'Knowledge',
                 tags: ['knowledge', 'documents', 'ingest', 'semantic', 'search'],
             },
+            {
+                name: impact_analysis_1.IMPACT_ANALYSIS_TOOL_NAME,
+                description: impact_analysis_1.IMPACT_ANALYSIS_TOOL_DESCRIPTION,
+                schema: impact_analysis_1.IMPACT_ANALYSIS_TOOL_INPUT_SCHEMA,
+                handler: async (args) => {
+                    const requestId = this.generateRequestId();
+                    this.logger.info(`Processing ${impact_analysis_1.IMPACT_ANALYSIS_TOOL_NAME} tool request`, { requestId });
+                    return await (0, impact_analysis_1.handleImpactAnalysisTool)(args, this.pluginManager);
+                },
+                category: 'Intelligence',
+                tags: ['impact', 'dependency', 'blast-radius', 'analysis', 'safety'],
+            },
         ];
     }
     /**