agent-consultation-mcp 1.0.0

package/dist/providers/openai.js

@@ -0,0 +1,123 @@
+import OpenAI from 'openai';
+import { MODEL_CONFIG } from '../types/index.js';
+import { BaseProvider } from './base.js';
+import { logger } from '../utils/index.js';
+/**
+ * OpenAI Provider - GPT-5.2 models
+ */
+export class OpenAIProvider extends BaseProvider {
+    name = 'openai';
+    client = null;
+    /**
+     * Get or create the OpenAI client
+     */
+    getClient() {
+        if (!this.client) {
+            const apiKey = this.getApiKey();
+            if (!apiKey) {
+                throw this.createError('AUTH_ERROR', 'OpenAI API key not configured', false);
+            }
+            this.client = new OpenAI({
+                apiKey,
+            });
+        }
+        return this.client;
+    }
+    /**
+     * Check if a model is a reasoning model
+     */
+    isReasoningModel(model) {
+        const config = MODEL_CONFIG[model];
+        return config?.isReasoning ?? false;
+    }
+    /**
+     * Get reasoning effort for the model
+     */
+    getReasoningEffort(model) {
+        const config = MODEL_CONFIG[model];
+        return config?.reasoningEffort;
+    }
+    /**
+     * Get the actual API model ID
+     */
+    getApiModel(model) {
+        const config = MODEL_CONFIG[model];
+        return config?.apiModel ?? model;
+    }
+    /**
+     * Create a chat completion
+     */
+    async createCompletion(messages, options) {
+        const client = this.getClient();
+        const apiModel = this.getApiModel(options.model);
+        const isReasoning = this.isReasoningModel(options.model);
+        const reasoningEffort = this.getReasoningEffort(options.model);
+        this.logRequest(apiModel, messages.length, options);
+        const startTime = Date.now();
+        try {
+            // Build messages array
+            const chatMessages = [];
+            // Add system prompt if provided
+            if (options.systemPrompt) {
+                chatMessages.push({
+                    role: 'system',
+                    content: options.systemPrompt,
+                });
+            }
+            // Add conversation messages
+            chatMessages.push(...messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })));
+            // Build request parameters
+            const requestParams = {
+                model: apiModel,
+                messages: chatMessages,
+                max_tokens: options.maxTokens || 4096,
+            };
+            // Add reasoning effort for GPT-5.2 models
+            if (isReasoning && reasoningEffort) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                requestParams.reasoning_effort = reasoningEffort;
+            }
+            // Set temperature for non-reasoning or if specified
+            if (options.temperature !== undefined) {
+                requestParams.temperature = options.temperature;
+            }
+            const response = await client.chat.completions.create(requestParams);
+            const choice = response.choices[0];
+            const content = choice?.message?.content || '';
+            const responseTime = Date.now() - startTime;
+            logger.debug('OpenAI response received', {
+                model: apiModel,
+                responseTime,
+                finishReason: choice?.finish_reason,
+            });
+            const result = {
+                content,
+                model: response.model,
+                usage: response.usage
+                    ? {
+                        promptTokens: response.usage.prompt_tokens,
+                        completionTokens: response.usage.completion_tokens,
+                        totalTokens: response.usage.total_tokens,
+                    }
+                    : undefined,
+                finishReason: choice?.finish_reason || undefined,
+                responseTime,
+            };
+            this.logResponse(result);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof OpenAI.APIError) {
+                const retryable = error.status === 429 ||
+                    error.status === 500 ||
+                    error.status === 503;
+                throw this.createError(error.code || 'API_ERROR', error.message, retryable, error.status);
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=openai.js.map

package/dist/providers/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.js","sourceRoot":"","sources":["../../src/providers/openai.ts"],"names":[],"mappings":"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"}

package/dist/providers/registry.d.ts

@@ -0,0 +1,37 @@
+import type { ProviderType } from '../types/index.js';
+import type { IProvider } from './types.js';
+/**
+ * Registry for managing provider instances
+ */
+export declare class ProviderRegistry {
+    private providers;
+    /**
+     * Register a provider
+     */
+    register(provider: IProvider): void;
+    /**
+     * Get a provider by name
+     */
+    getProvider(name: ProviderType): IProvider;
+    /**
+     * Check if a provider exists
+     */
+    hasProvider(name: ProviderType): boolean;
+    /**
+     * Get all registered providers
+     */
+    getAllProviders(): IProvider[];
+    /**
+     * Get all configured providers
+     */
+    getConfiguredProviders(): IProvider[];
+}
+/**
+ * Get the provider registry instance
+ */
+export declare function getProviderRegistry(): ProviderRegistry;
+/**
+ * Initialize the registry with all providers
+ * Called during server startup
+ */
+export declare function initializeProviders(): Promise<void>;

package/dist/providers/registry.js

@@ -0,0 +1,65 @@
+/**
+ * Registry for managing provider instances
+ */
+export class ProviderRegistry {
+    providers = new Map();
+    /**
+     * Register a provider
+     */
+    register(provider) {
+        this.providers.set(provider.name, provider);
+    }
+    /**
+     * Get a provider by name
+     */
+    getProvider(name) {
+        const provider = this.providers.get(name);
+        if (!provider) {
+            throw new Error(`Provider not found: ${name}`);
+        }
+        return provider;
+    }
+    /**
+     * Check if a provider exists
+     */
+    hasProvider(name) {
+        return this.providers.has(name);
+    }
+    /**
+     * Get all registered providers
+     */
+    getAllProviders() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * Get all configured providers
+     */
+    getConfiguredProviders() {
+        return this.getAllProviders().filter((p) => p.isConfigured());
+    }
+}
+// Singleton instance
+let registryInstance = null;
+/**
+ * Get the provider registry instance
+ */
+export function getProviderRegistry() {
+    if (!registryInstance) {
+        registryInstance = new ProviderRegistry();
+    }
+    return registryInstance;
+}
+/**
+ * Initialize the registry with all providers
+ * Called during server startup
+ */
+export async function initializeProviders() {
+    const registry = getProviderRegistry();
+    // Import providers dynamically to avoid circular dependencies
+    const { DeepSeekProvider } = await import('./deepseek.js');
+    const { OpenAIProvider } = await import('./openai.js');
+    // Register providers
+    registry.register(new DeepSeekProvider());
+    registry.register(new OpenAIProvider());
+}
+//# sourceMappingURL=registry.js.map

package/dist/providers/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,OAAO,gBAAgB;IACnB,SAAS,GAAiC,IAAI,GAAG,EAAE,CAAC;IAE5D;;OAEG;IACH,QAAQ,CAAC,QAAmB;QAC1B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,IAAkB;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,IAAkB;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,sBAAsB;QACpB,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC;IAChE,CAAC;CACF;AAED,qBAAqB;AACrB,IAAI,gBAAgB,GAA4B,IAAI,CAAC;AAErD;;GAEG;AACH,MAAM,UAAU,mBAAmB;IACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB;IACvC,MAAM,QAAQ,GAAG,mBAAmB,EAAE,CAAC;IAEvC,8DAA8D;IAC9D,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,eAAe,CAAC,CAAC;IAC3D,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;IAEvD,qBAAqB;IACrB,QAAQ,CAAC,QAAQ,CAAC,IAAI,gBAAgB,EAAE,CAAC,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,IAAI,cAAc,EAAE,CAAC,CAAC;AAC1C,CAAC"}

package/dist/providers/types.d.ts

@@ -0,0 +1,71 @@
+import type { ModelType, ProviderType } from '../types/index.js';
+/**
+ * Message format for provider communication
+ */
+export interface ProviderMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+/**
+ * Options for creating a completion
+ */
+export interface CompletionOptions {
+    model: ModelType;
+    systemPrompt?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Token usage information
+ */
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Response from a provider
+ */
+export interface ProviderResponse {
+    content: string;
+    model: string;
+    usage?: TokenUsage;
+    finishReason?: string;
+    reasoningContent?: string;
+    responseTime?: number;
+}
+/**
+ * Provider error information
+ */
+export interface ProviderErrorInfo {
+    provider: ProviderType;
+    code: string;
+    message: string;
+    retryable: boolean;
+    statusCode?: number;
+}
+/**
+ * Provider interface - all providers must implement this
+ */
+export interface IProvider {
+    readonly name: ProviderType;
+    /**
+     * Check if the provider is configured with valid credentials
+     */
+    isConfigured(): boolean;
+    /**
+     * Create a chat completion
+     */
+    createCompletion(messages: ProviderMessage[], options: CompletionOptions): Promise<ProviderResponse>;
+}
+/**
+ * Model configuration
+ */
+export interface ModelConfig {
+    provider: ProviderType;
+    apiModel: string;
+    maxTokens: number;
+    supportsSystemPrompt: boolean;
+    isReasoning: boolean;
+    reasoningEffort?: 'low' | 'medium' | 'high';
+}

package/dist/providers/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/providers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/providers/types.ts"],"names":[],"mappings":""}

package/dist/server/conversation.d.ts

@@ -0,0 +1,101 @@
+import type { Message, ModelType } from '../types/index.js';
+/**
+ * Serializable conversation for file storage
+ */
+interface SerializedConversation {
+    id: string;
+    model: ModelType;
+    messages: Message[];
+    systemPrompt: string;
+    createdAt: string;
+    lastActivityAt: string;
+}
+/**
+ * Archived conversation with end reason
+ */
+export interface ArchivedConversation extends SerializedConversation {
+    endedAt: string;
+    endReason: 'completed' | 'timeout' | 'manual' | 'session_restart';
+}
+/**
+ * Represents an active conversation
+ */
+export interface Conversation {
+    id: string;
+    model: ModelType;
+    messages: Message[];
+    systemPrompt: string;
+    createdAt: Date;
+    lastActivityAt: Date;
+}
+/**
+ * Manages active conversations with file persistence
+ */
+export declare class ConversationManager {
+    private conversations;
+    private cleanupInterval;
+    constructor();
+    /**
+     * Archive all active conversations from previous session
+     * Called on startup to clean up orphaned conversations
+     */
+    private archiveStaleFromPreviousSession;
+    /**
+     * Save conversations to file
+     */
+    private saveToFile;
+    /**
+     * Load conversations from file (static method for external use)
+     */
+    static loadFromFile(): Conversation[];
+    /**
+     * Load archived conversations from history file (static method for external use)
+     */
+    static loadHistoryFromFile(): ArchivedConversation[];
+    /**
+     * Archive a conversation to history file
+     */
+    private archiveConversation;
+    /**
+     * Create a new conversation
+     */
+    create(model: ModelType, systemPrompt: string): Conversation;
+    /**
+     * Get a conversation by ID
+     */
+    get(conversationId: string): Conversation;
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(conversationId: string, role: Message['role'], content: string): void;
+    /**
+     * Check if conversation can continue
+     */
+    canContinue(conversationId: string): boolean;
+    /**
+     * Get message count for a conversation
+     */
+    getMessageCount(conversationId: string): number;
+    /**
+     * End a conversation (archives it to history)
+     */
+    end(conversationId: string): number;
+    /**
+     * List all active conversations
+     */
+    listActive(): Conversation[];
+    /**
+     * Start periodic cleanup of stale conversations
+     */
+    private startCleanup;
+    /**
+     * Clean up stale conversations (archives them to history)
+     */
+    private cleanupStale;
+    /**
+     * Stop the cleanup interval
+     */
+    destroy(): void;
+}
+export declare const conversationManager: ConversationManager;
+export {};

package/dist/server/conversation.js

@@ -0,0 +1,275 @@
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { ConversationError } from '../utils/index.js';
+import { MAX_MESSAGES_LIMIT, CONVERSATION_TIMEOUT_MS } from '../config/index.js';
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Conversations file path (in config directory)
+const CONVERSATIONS_FILE = path.join(__dirname, '../../config/conversations.json');
+const HISTORY_FILE = path.join(__dirname, '../../config/conversation_history.json');
+/**
+ * Manages active conversations with file persistence
+ */
+export class ConversationManager {
+    conversations = new Map();
+    cleanupInterval = null;
+    constructor() {
+        // Archive any leftover active conversations from previous session
+        this.archiveStaleFromPreviousSession();
+        // Start cleanup interval
+        this.startCleanup();
+    }
+    /**
+     * Archive all active conversations from previous session
+     * Called on startup to clean up orphaned conversations
+     */
+    archiveStaleFromPreviousSession() {
+        try {
+            if (!fs.existsSync(CONVERSATIONS_FILE)) {
+                return;
+            }
+            const data = fs.readFileSync(CONVERSATIONS_FILE, 'utf-8');
+            const serialized = JSON.parse(data);
+            if (serialized.length === 0) {
+                return;
+            }
+            console.log(`[ConversationManager] Archiving ${serialized.length} conversations from previous session`);
+            // Archive each conversation
+            for (const conv of serialized) {
+                const conversation = {
+                    id: conv.id,
+                    model: conv.model,
+                    messages: conv.messages,
+                    systemPrompt: conv.systemPrompt,
+                    createdAt: new Date(conv.createdAt),
+                    lastActivityAt: new Date(conv.lastActivityAt),
+                };
+                this.archiveConversation(conversation, 'session_restart');
+            }
+            // Clear the active conversations file
+            fs.writeFileSync(CONVERSATIONS_FILE, '[]', 'utf-8');
+        }
+        catch (error) {
+            console.error('[ConversationManager] Failed to archive previous session conversations:', error);
+        }
+    }
+    /**
+     * Save conversations to file
+     */
+    saveToFile() {
+        try {
+            const data = Array.from(this.conversations.values()).map(conv => ({
+                id: conv.id,
+                model: conv.model,
+                messages: conv.messages,
+                systemPrompt: conv.systemPrompt,
+                createdAt: conv.createdAt.toISOString(),
+                lastActivityAt: conv.lastActivityAt.toISOString(),
+            }));
+            // Ensure config directory exists
+            const configDir = path.dirname(CONVERSATIONS_FILE);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            fs.writeFileSync(CONVERSATIONS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to save conversations:', error);
+        }
+    }
+    /**
+     * Load conversations from file (static method for external use)
+     */
+    static loadFromFile() {
+        try {
+            if (!fs.existsSync(CONVERSATIONS_FILE)) {
+                return [];
+            }
+            const data = fs.readFileSync(CONVERSATIONS_FILE, 'utf-8');
+            const serialized = JSON.parse(data);
+            return serialized.map(conv => ({
+                id: conv.id,
+                model: conv.model,
+                messages: conv.messages,
+                systemPrompt: conv.systemPrompt,
+                createdAt: new Date(conv.createdAt),
+                lastActivityAt: new Date(conv.lastActivityAt),
+            }));
+        }
+        catch (error) {
+            console.error('Failed to load conversations:', error);
+            return [];
+        }
+    }
+    /**
+     * Load archived conversations from history file (static method for external use)
+     */
+    static loadHistoryFromFile() {
+        try {
+            if (!fs.existsSync(HISTORY_FILE)) {
+                return [];
+            }
+            const data = fs.readFileSync(HISTORY_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            console.error('Failed to load conversation history:', error);
+            return [];
+        }
+    }
+    /**
+     * Archive a conversation to history file
+     */
+    archiveConversation(conversation, reason) {
+        try {
+            // Load existing history
+            let history = [];
+            if (fs.existsSync(HISTORY_FILE)) {
+                const data = fs.readFileSync(HISTORY_FILE, 'utf-8');
+                history = JSON.parse(data);
+            }
+            // Add archived conversation
+            const archived = {
+                id: conversation.id,
+                model: conversation.model,
+                messages: conversation.messages,
+                systemPrompt: conversation.systemPrompt,
+                createdAt: conversation.createdAt.toISOString(),
+                lastActivityAt: conversation.lastActivityAt.toISOString(),
+                endedAt: new Date().toISOString(),
+                endReason: reason,
+            };
+            history.unshift(archived); // Add to beginning (newest first)
+            // Keep only last 100 conversations
+            if (history.length > 100) {
+                history = history.slice(0, 100);
+            }
+            // Ensure config directory exists
+            const configDir = path.dirname(HISTORY_FILE);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to archive conversation:', error);
+        }
+    }
+    /**
+     * Create a new conversation
+     */
+    create(model, systemPrompt) {
+        const conversation = {
+            id: uuidv4(),
+            model,
+            messages: [],
+            systemPrompt,
+            createdAt: new Date(),
+            lastActivityAt: new Date(),
+        };
+        this.conversations.set(conversation.id, conversation);
+        this.saveToFile();
+        return conversation;
+    }
+    /**
+     * Get a conversation by ID
+     */
+    get(conversationId) {
+        const conversation = this.conversations.get(conversationId);
+        if (!conversation) {
+            throw new ConversationError(`Conversation not found: ${conversationId}`, conversationId);
+        }
+        return conversation;
+    }
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(conversationId, role, content) {
+        const conversation = this.get(conversationId);
+        // Check message limit
+        if (conversation.messages.length >= MAX_MESSAGES_LIMIT * 2) {
+            throw new ConversationError(`Maximum message limit (${MAX_MESSAGES_LIMIT} exchanges) reached`, conversationId);
+        }
+        conversation.messages.push({ role, content });
+        conversation.lastActivityAt = new Date();
+        this.saveToFile();
+    }
+    /**
+     * Check if conversation can continue
+     */
+    canContinue(conversationId) {
+        const conversation = this.get(conversationId);
+        // Each exchange = 1 user + 1 assistant message = 2 messages
+        // maxMessages represents exchanges, so multiply by 2
+        return conversation.messages.length < MAX_MESSAGES_LIMIT * 2;
+    }
+    /**
+     * Get message count for a conversation
+     */
+    getMessageCount(conversationId) {
+        const conversation = this.get(conversationId);
+        return conversation.messages.length;
+    }
+    /**
+     * End a conversation (archives it to history)
+     */
+    end(conversationId) {
+        const conversation = this.get(conversationId);
+        const totalMessages = conversation.messages.length;
+        // Archive before deleting
+        this.archiveConversation(conversation, 'completed');
+        this.conversations.delete(conversationId);
+        this.saveToFile();
+        return totalMessages;
+    }
+    /**
+     * List all active conversations
+     */
+    listActive() {
+        return Array.from(this.conversations.values());
+    }
+    /**
+     * Start periodic cleanup of stale conversations
+     */
+    startCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupStale();
+        }, 60000); // Check every minute
+    }
+    /**
+     * Clean up stale conversations (archives them to history)
+     */
+    cleanupStale() {
+        const now = Date.now();
+        let changed = false;
+        for (const [id, conversation] of this.conversations) {
+            const age = now - conversation.lastActivityAt.getTime();
+            if (age > CONVERSATION_TIMEOUT_MS) {
+                // Archive before deleting
+                this.archiveConversation(conversation, 'timeout');
+                this.conversations.delete(id);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.saveToFile();
+        }
+    }
+    /**
+     * Stop the cleanup interval
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.conversations.clear();
+        this.saveToFile();
+    }
+}
+// Singleton instance
+export const conversationManager = new ConversationManager();
+//# sourceMappingURL=conversation.js.map