@klitchevo/code-council 0.0.8 → 0.0.11

package/README.md

@@ -18,6 +18,7 @@ An MCP (Model Context Protocol) server that provides AI-powered code review usin
 - 🔒 **Backend Review** - Security, architecture, and performance analysis
 - 📋 **Plan Review** - Review implementation plans before writing code
 - 📝 **Git Changes Review** - Review staged, unstaged, branch diffs, or specific commits
+- 💬 **Council Discussions** - Multi-turn conversations with the AI council for deeper exploration
 - ⚡ **Parallel Execution** - All models run concurrently for fast results
 
 ## Quick Start
@@ -257,6 +258,32 @@ Use review_git_changes to review my staged changes
 Use review_git_changes with review_type=commit and commit_hash=abc123 to review that commit
 ```
 
+### `discuss_with_council`
+
+Have multi-turn conversations with the AI council. Start a discussion, get feedback from all models, then ask follow-up questions while maintaining context.
+
+**Parameters:**
+- `message` (required): Your message or question for the council
+- `session_id` (optional): Session ID to continue an existing discussion (omit to start new)
+- `discussion_type` (optional): `code_review`, `plan_review`, or `general` (default: `general`)
+- `context` (optional): Additional context (code snippets, plan details, etc.)
+
+**Example usage in Claude:**
+```
+Use discuss_with_council to ask: What's the best way to implement error handling in a Node.js API?
+```
+
+**Continuing a discussion:**
+```
+Use discuss_with_council with session_id=<id-from-previous-response> to ask: Can you elaborate on the circuit breaker pattern you mentioned?
+```
+
+**Key features:**
+- Each model maintains its own conversation history for authentic diverse perspectives
+- Sessions persist for 30 minutes of inactivity
+- Rate limited to 10 requests per minute per session
+- Context windowing keeps conversations efficient
+
 ### `list_review_config`
 
 Show which AI models are currently configured for each review type.
@@ -272,6 +299,7 @@ You can customize which AI models are used for reviews by setting environment va
 - `FRONTEND_REVIEW_MODELS` - Models for frontend reviews
 - `BACKEND_REVIEW_MODELS` - Models for backend reviews
 - `PLAN_REVIEW_MODELS` - Models for plan reviews
+- `DISCUSSION_MODELS` - Models for council discussions
 - `TEMPERATURE` - Control response randomness (0.0-2.0, default: 0.3)
 - `MAX_TOKENS` - Maximum response tokens (default: 16384)
 
@@ -299,9 +327,10 @@ You can customize which AI models are used for reviews by setting environment va
 
 **Default Models:**
 If you don't specify models, the server uses these defaults:
-- `minimax/minimax-m2.1`
-- `z-ai/glm-4.7`
-- `x-ai/grok-code-fast-1`
+- `minimax/minimax-m2.1` - Fast, cost-effective reasoning
+- `z-ai/glm-4.7` - Strong multilingual capabilities
+- `moonshotai/kimi-k2-thinking` - Advanced reasoning with thinking
+- `deepseek/deepseek-v3.2` - State-of-the-art open model
 
 **Finding Models:**
 Browse all available models at [OpenRouter Models](https://openrouter.ai/models). Popular choices include:

package/dist/index.js

@@ -14,8 +14,25 @@ var LLM_CONFIG = {
 var DEFAULT_MODELS = [
   "minimax/minimax-m2.1",
   "z-ai/glm-4.7",
-  "x-ai/grok-code-fast-1"
+  "moonshotai/kimi-k2-thinking",
+  "deepseek/deepseek-v3.2"
 ];
+var SESSION_LIMITS = {
+  /** Maximum number of concurrent sessions */
+  MAX_SESSIONS: 100,
+  /** Maximum messages per model in a session (context windowing) */
+  MAX_MESSAGES_PER_MODEL: 50,
+  /** Maximum message length in bytes (10KB) */
+  MAX_MESSAGE_LENGTH: 10 * 1024,
+  /** Session TTL in milliseconds (30 minutes) */
+  TTL_MS: 30 * 60 * 1e3,
+  /** Cleanup interval in milliseconds (5 minutes) */
+  CLEANUP_INTERVAL_MS: 5 * 60 * 1e3,
+  /** Rate limit: max requests per session per minute */
+  RATE_LIMIT_PER_MINUTE: 10,
+  /** Per-model timeout in milliseconds (30 seconds) */
+  MODEL_TIMEOUT_MS: 30 * 1e3
+};
 
 // src/config.ts
 function parseModels(envVar, defaults) {
@@ -26,17 +43,15 @@ function parseModels(envVar, defaults) {
     const filtered = envVar.filter((m) => m && m.trim().length > 0);
     return filtered.length > 0 ? filtered : defaults;
   }
-  if (typeof envVar === "string") {
-    try {
-      const parsed = JSON.parse(envVar);
-      if (Array.isArray(parsed)) {
-        const filtered = parsed.filter(
-          (m) => typeof m === "string" && m.trim().length > 0
-        );
-        return filtered.length > 0 ? filtered : defaults;
-      }
-    } catch {
+  try {
+    const parsed = JSON.parse(envVar);
+    if (Array.isArray(parsed)) {
+      const filtered = parsed.filter(
+        (m) => typeof m === "string" && m.trim().length > 0
+      );
+      return filtered.length > 0 ? filtered : defaults;
     }
+  } catch {
   }
   throw new Error(
     `Model configuration must be an array of strings, got: ${typeof envVar}. Example: ["anthropic/claude-sonnet-4.5", "openai/gpt-4o"]`
@@ -58,6 +73,10 @@ var PLAN_REVIEW_MODELS = parseModels(
   process.env.PLAN_REVIEW_MODELS,
   DEFAULT_MODELS
 );
+var DISCUSSION_MODELS = parseModels(
+  process.env.DISCUSSION_MODELS,
+  DEFAULT_MODELS
+);
 
 // src/logger.ts
 var Logger = class {
@@ -138,6 +157,16 @@ var OpenRouterError = class extends AppError {
     this.retryable = retryable;
   }
 };
+var ValidationError = class extends AppError {
+  constructor(message, field) {
+    super(
+      message,
+      "VALIDATION_ERROR",
+      `Invalid input for ${field}: ${message}`
+    );
+    this.field = field;
+  }
+};
 function formatErrorMessage(error) {
   if (error instanceof AppError) {
     return error.userMessage || error.message;
@@ -401,8 +430,557 @@ var ReviewClient = class {
       (model) => this.chat(model, SYSTEM_PROMPT4, userMessage)
     );
   }
+  /**
+   * Send a multi-turn chat request with full message history
+   * @param model - Model identifier
+   * @param messages - Full conversation history
+   * @param timeoutMs - Optional timeout in milliseconds
+   * @returns The model's response content
+   * @throws {OpenRouterError} If the API call fails or times out
+   */
+  async chatMultiTurn(model, messages, timeoutMs) {
+    const timeout = timeoutMs ?? SESSION_LIMITS.MODEL_TIMEOUT_MS;
+    try {
+      logger.debug("Sending multi-turn chat request", {
+        model,
+        messageCount: messages.length
+      });
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await this.client.chat.send({
+          model,
+          messages: messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          temperature: LLM_CONFIG.DEFAULT_TEMPERATURE,
+          maxTokens: LLM_CONFIG.DEFAULT_MAX_TOKENS
+        });
+        clearTimeout(timeoutId);
+        const content = response.choices?.[0]?.message?.content;
+        if (typeof content === "string") {
+          logger.debug("Received multi-turn response", {
+            model,
+            length: content.length
+          });
+          return content;
+        }
+        if (Array.isArray(content)) {
+          const text = content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+          logger.debug("Received array response", {
+            model,
+            length: text.length
+          });
+          return text;
+        }
+        throw new OpenRouterError("No response content from model", 500);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      if (error instanceof OpenRouterError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Multi-turn chat request failed", error, { model });
+      if (message.includes("abort") || message.includes("timeout") || error instanceof Error && error.name === "AbortError") {
+        throw new OpenRouterError(
+          `Request timed out after ${timeout}ms`,
+          408,
+          true
+        );
+      }
+      const isRetryable = message.includes("429") || message.includes("rate limit");
+      throw new OpenRouterError(message, void 0, isRetryable);
+    }
+  }
+  /**
+   * Conduct a council discussion with multiple models
+   * Each model uses its own conversation history from the provided function
+   * @param models - Array of model identifiers
+   * @param getMessagesForModel - Function to get messages for each model
+   * @returns Array of results from each model
+   */
+  async discussWithCouncil(models, getMessagesForModel) {
+    return executeInParallel([...models], async (model) => {
+      const messages = getMessagesForModel(model);
+      return this.chatMultiTurn(model, messages);
+    });
+  }
+};
+
+// src/session/in-memory-store.ts
+import { randomUUID } from "crypto";
+
+// src/session/types.ts
+var DISCUSSION_TYPES = [
+  "code_review",
+  "plan_review",
+  "general"
+];
+function toSessionId(id) {
+  return id;
+}
+
+// src/session/in-memory-store.ts
+var InMemorySessionStore = class {
+  sessions = {};
+  rateLimits = {};
+  cleanupInterval = null;
+  ttlMs;
+  maxSessions;
+  maxMessagesPerModel;
+  rateLimitPerMinute;
+  constructor(options) {
+    this.ttlMs = options?.ttlMs ?? SESSION_LIMITS.TTL_MS;
+    this.maxSessions = options?.maxSessions ?? SESSION_LIMITS.MAX_SESSIONS;
+    this.maxMessagesPerModel = options?.maxMessagesPerModel ?? SESSION_LIMITS.MAX_MESSAGES_PER_MODEL;
+    this.rateLimitPerMinute = options?.rateLimitPerMinute ?? SESSION_LIMITS.RATE_LIMIT_PER_MINUTE;
+    const cleanupIntervalMs = options?.cleanupIntervalMs ?? SESSION_LIMITS.CLEANUP_INTERVAL_MS;
+    this.startCleanupTimer(cleanupIntervalMs);
+  }
+  createSession(options) {
+    const sessionCount = Object.keys(this.sessions).length;
+    if (sessionCount >= this.maxSessions) {
+      this.evictOldestSession();
+    }
+    const sessionId = toSessionId(randomUUID());
+    const now = Date.now();
+    const modelConversations = {};
+    for (const model of options.models) {
+      modelConversations[model] = {
+        model,
+        messages: [
+          { role: "system", content: options.systemPrompt, timestamp: now },
+          {
+            role: "user",
+            content: options.initialUserMessage,
+            timestamp: now
+          }
+        ],
+        lastActive: now
+      };
+    }
+    const session = {
+      id: sessionId,
+      topic: options.topic,
+      discussionType: options.discussionType,
+      modelConversations,
+      createdAt: now,
+      lastActiveAt: now,
+      models: [...options.models]
+    };
+    this.sessions[sessionId] = session;
+    this.rateLimits[sessionId] = {
+      sessionId,
+      requestCount: 1,
+      // Count the initial creation
+      windowStart: now
+    };
+    logger.info("Created discussion session", {
+      sessionId,
+      topic: options.topic,
+      discussionType: options.discussionType,
+      modelCount: options.models.length
+    });
+    return session;
+  }
+  getSession(id) {
+    const session = this.sessions[id];
+    if (session) {
+      session.lastActiveAt = Date.now();
+    }
+    return session;
+  }
+  addUserMessage(id, message) {
+    const session = this.sessions[id];
+    if (!session) {
+      return false;
+    }
+    const now = Date.now();
+    session.lastActiveAt = now;
+    for (const model of session.models) {
+      const conversation = session.modelConversations[model];
+      if (conversation) {
+        if (conversation.messages.length >= this.maxMessagesPerModel) {
+          const systemMsg = conversation.messages[0];
+          if (systemMsg) {
+            conversation.messages = [
+              systemMsg,
+              ...conversation.messages.slice(-(this.maxMessagesPerModel - 2))
+            ];
+          }
+        }
+        conversation.messages.push({
+          role: "user",
+          content: message,
+          timestamp: now
+        });
+        conversation.lastActive = now;
+      }
+    }
+    return true;
+  }
+  addAssistantMessage(id, model, response) {
+    const session = this.sessions[id];
+    if (!session) {
+      return false;
+    }
+    const conversation = session.modelConversations[model];
+    if (!conversation) {
+      return false;
+    }
+    const now = Date.now();
+    conversation.messages.push({
+      role: "assistant",
+      content: response,
+      timestamp: now
+    });
+    conversation.lastActive = now;
+    session.lastActiveAt = now;
+    return true;
+  }
+  getModelMessages(id, model) {
+    const session = this.sessions[id];
+    if (!session) {
+      return void 0;
+    }
+    session.lastActiveAt = Date.now();
+    return session.modelConversations[model]?.messages;
+  }
+  deleteSession(id) {
+    const existed = id in this.sessions;
+    if (existed) {
+      delete this.sessions[id];
+      delete this.rateLimits[id];
+      logger.debug("Deleted session", { sessionId: id });
+    }
+    return existed;
+  }
+  getSessionCount() {
+    return Object.keys(this.sessions).length;
+  }
+  checkRateLimit(id) {
+    const now = Date.now();
+    const windowMs = 60 * 1e3;
+    const state = this.rateLimits[id];
+    if (!state) {
+      return {
+        allowed: false,
+        remainingRequests: 0,
+        resetInMs: 0
+      };
+    }
+    if (now - state.windowStart >= windowMs) {
+      state.requestCount = 0;
+      state.windowStart = now;
+    }
+    const remaining = this.rateLimitPerMinute - state.requestCount;
+    const resetInMs = windowMs - (now - state.windowStart);
+    if (state.requestCount >= this.rateLimitPerMinute) {
+      return {
+        allowed: false,
+        remainingRequests: 0,
+        resetInMs
+      };
+    }
+    state.requestCount++;
+    return {
+      allowed: true,
+      remainingRequests: remaining - 1,
+      resetInMs
+    };
+  }
+  shutdown() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    const sessionCount = Object.keys(this.sessions).length;
+    this.sessions = {};
+    this.rateLimits = {};
+    logger.info("Session store shutdown", { clearedSessions: sessionCount });
+  }
+  /**
+   * Start the periodic cleanup timer
+   */
+  startCleanupTimer(intervalMs) {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, intervalMs);
+    this.cleanupInterval.unref();
+  }
+  /**
+   * Remove sessions that have exceeded the TTL
+   */
+  cleanupExpiredSessions() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const sessionId of Object.keys(this.sessions)) {
+      const session = this.sessions[sessionId];
+      if (session && now - session.lastActiveAt > this.ttlMs) {
+        delete this.sessions[sessionId];
+        delete this.rateLimits[sessionId];
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      logger.info("Cleaned up expired sessions", { count: cleaned });
+    }
+  }
+  /**
+   * Evict the oldest session when at capacity (LRU eviction)
+   */
+  evictOldestSession() {
+    let oldestId = null;
+    let oldestTime = Number.POSITIVE_INFINITY;
+    for (const sessionId of Object.keys(this.sessions)) {
+      const session = this.sessions[sessionId];
+      if (session && session.lastActiveAt < oldestTime) {
+        oldestTime = session.lastActiveAt;
+        oldestId = sessionId;
+      }
+    }
+    if (oldestId) {
+      delete this.sessions[oldestId];
+      delete this.rateLimits[oldestId];
+      logger.warn("Evicted oldest session due to capacity", {
+        sessionId: oldestId
+      });
+    }
+  }
 };
 
+// src/tools/conversation-factory.ts
+function formatDiscussionResults(results, sessionId, isNewSession, topic) {
+  const header = isNewSession ? `# Council Discussion Started
+
+**Topic:** ${topic}
+**Session ID:** \`${sessionId}\`
+
+_Use this session_id in subsequent calls to continue the discussion._
+
+---
+
+` : `# Council Discussion Continued
+
+**Session ID:** \`${sessionId}\`
+
+---
+
+`;
+  const responses = results.map((r) => {
+    const modelName = r.model.split("/").pop() || r.model;
+    if (r.error) {
+      return `## ${modelName}
+
+**Error:** ${r.error}`;
+    }
+    return `## ${modelName}
+
+${r.review}`;
+  }).join("\n\n---\n\n");
+  const footer = `
+
+---
+
+**Session ID:** \`${sessionId}\` _(include in your next message to continue)_`;
+  return header + responses + footer;
+}
+function createConversationTool(server2, config, sessionStore2) {
+  server2.registerTool(
+    config.name,
+    {
+      description: config.description,
+      inputSchema: config.inputSchema
+    },
+    async (input) => {
+      try {
+        logger.debug(`Starting ${config.name}`, {
+          inputKeys: Object.keys(input)
+        });
+        const { results, models, sessionId, isNewSession, topic } = await config.handler(input, sessionStore2);
+        logger.info(`Completed ${config.name}`, {
+          sessionId,
+          isNewSession,
+          modelCount: models.length,
+          successCount: results.filter((r) => !r.error).length,
+          errorCount: results.filter((r) => r.error).length
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatDiscussionResults(
+                results,
+                sessionId,
+                isNewSession,
+                topic
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error(
+          `Error in ${config.name}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        return formatError(error);
+      }
+    }
+  );
+}
+
+// src/tools/discuss-council.ts
+import { z } from "zod";
+
+// src/prompts/discussion.ts
+var DISCUSSION_SYSTEM_PROMPTS = {
+  code_review: `You are a senior software engineer participating in a code review council discussion.
+
+Your role:
+- Provide thoughtful, constructive feedback on code and technical decisions
+- Build on your previous responses in this conversation
+- Consider alternative approaches and trade-offs
+- Be specific with examples and suggestions
+- Respectfully challenge ideas while remaining collaborative
+
+Focus on code quality, maintainability, performance, security, and best practices.
+Keep responses focused and actionable.`,
+  plan_review: `You are a senior software architect participating in a planning council discussion.
+
+Your role:
+- Evaluate implementation plans, architecture decisions, and technical strategies
+- Build on your previous responses in this conversation
+- Consider feasibility, risks, scalability, and maintainability
+- Suggest alternatives and improvements
+- Think about edge cases and potential issues
+
+Focus on practical implementation concerns and long-term implications.
+Keep responses focused and actionable.`,
+  general: `You are a knowledgeable advisor participating in a council discussion.
+
+Your role:
+- Provide thoughtful, well-reasoned perspectives on the topic
+- Build on your previous responses in this conversation
+- Consider multiple viewpoints and trade-offs
+- Support your points with examples and reasoning
+- Be open to exploring different approaches
+
+Keep responses focused and constructive.`
+};
+function getSystemPrompt(discussionType) {
+  return DISCUSSION_SYSTEM_PROMPTS[discussionType];
+}
+function buildInitialMessage(message, discussionType, context) {
+  const typeLabel = {
+    code_review: "Code Review Discussion",
+    plan_review: "Plan Review Discussion",
+    general: "Discussion"
+  };
+  let content = `**${typeLabel[discussionType]}**
+
+${message}`;
+  if (context) {
+    content += `
+
+**Additional Context:**
+${context}`;
+  }
+  return content;
+}
+
+// src/tools/discuss-council.ts
+var discussCouncilSchema = {
+  message: z.string().min(1, "Message cannot be empty").max(
+    SESSION_LIMITS.MAX_MESSAGE_LENGTH,
+    `Message exceeds maximum length of ${SESSION_LIMITS.MAX_MESSAGE_LENGTH} characters`
+  ).describe("Your message or question for the council"),
+  session_id: z.string().uuid("Invalid session ID format").optional().describe(
+    "Session ID to continue an existing discussion. Omit to start a new discussion."
+  ),
+  discussion_type: z.enum(DISCUSSION_TYPES).optional().describe(
+    "Type of discussion (only used when starting new session). 'code_review' for code-related discussions, 'plan_review' for architecture/planning, 'general' for other topics. Default: general"
+  ),
+  context: z.string().max(
+    SESSION_LIMITS.MAX_MESSAGE_LENGTH,
+    `Context exceeds maximum length of ${SESSION_LIMITS.MAX_MESSAGE_LENGTH} characters`
+  ).optional().describe(
+    "Additional context for new discussions (code snippets, plan details, etc.)"
+  )
+};
+async function handleDiscussCouncil(client2, input, sessionStore2) {
+  const { message, session_id, discussion_type, context } = input;
+  let sessionId;
+  let isNewSession = false;
+  if (session_id) {
+    sessionId = toSessionId(session_id);
+    const existingSession = sessionStore2.getSession(sessionId);
+    if (!existingSession) {
+      throw new ValidationError(
+        `Session not found: ${session_id}. It may have expired or been deleted.`,
+        "session_id"
+      );
+    }
+    const rateLimitResult = sessionStore2.checkRateLimit(sessionId);
+    if (!rateLimitResult.allowed) {
+      throw new ValidationError(
+        `Rate limit exceeded. Please wait ${Math.ceil(rateLimitResult.resetInMs / 1e3)} seconds before sending another message.`,
+        "session_id"
+      );
+    }
+    sessionStore2.addUserMessage(sessionId, message);
+    logger.info("Continuing council discussion", {
+      sessionId,
+      modelCount: existingSession.models.length
+    });
+  } else {
+    isNewSession = true;
+    const type = discussion_type || "general";
+    const systemPrompt = getSystemPrompt(type);
+    const initialMessage = buildInitialMessage(message, type, context);
+    const topic = message.length > 100 ? `${message.slice(0, 97)}...` : message;
+    const session2 = sessionStore2.createSession({
+      topic,
+      discussionType: type,
+      models: DISCUSSION_MODELS,
+      systemPrompt,
+      initialUserMessage: initialMessage
+    });
+    sessionId = session2.id;
+    logger.info("Started new council discussion", {
+      sessionId,
+      discussionType: type,
+      modelCount: DISCUSSION_MODELS.length
+    });
+  }
+  const session = sessionStore2.getSession(sessionId);
+  if (!session) {
+    throw new ValidationError("Session was unexpectedly deleted", "session_id");
+  }
+  const currentSessionId = sessionId;
+  const results = await client2.discussWithCouncil(session.models, (model) => {
+    const messages = sessionStore2.getModelMessages(currentSessionId, model);
+    if (!messages) {
+      throw new Error(`No messages found for model ${model}`);
+    }
+    return messages;
+  });
+  for (const result of results) {
+    if (!result.error && result.review) {
+      sessionStore2.addAssistantMessage(sessionId, result.model, result.review);
+    }
+  }
+  return {
+    results,
+    models: session.models,
+    sessionId,
+    isNewSession,
+    topic: session.topic
+  };
+}
+
 // src/tools/factory.ts
 function formatResults(results) {
   return results.map((r) => {
@@ -485,12 +1063,12 @@ To customize models, set environment variables in your MCP config:
 }
 
 // src/tools/review-backend.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var backendReviewSchema = {
-  code: z.string().describe("The backend code to review"),
-  language: z.string().optional().describe("Programming language/framework (e.g., node, python, go, rust)"),
-  review_type: z.enum(["security", "performance", "architecture", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z.string().optional().describe("Additional context")
+  code: z2.string().describe("The backend code to review"),
+  language: z2.string().optional().describe("Programming language/framework (e.g., node, python, go, rust)"),
+  review_type: z2.enum(["security", "performance", "architecture", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z2.string().optional().describe("Additional context")
 };
 async function handleBackendReview(client2, input) {
   const { code, language, review_type, context } = input;
@@ -513,11 +1091,11 @@ async function handleBackendReview(client2, input) {
 }
 
 // src/tools/review-code.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var codeReviewSchema = {
-  code: z2.string().describe("The code to review"),
-  language: z2.string().optional().describe("Programming language of the code"),
-  context: z2.string().optional().describe("Additional context about the code")
+  code: z3.string().describe("The code to review"),
+  language: z3.string().optional().describe("Programming language of the code"),
+  context: z3.string().optional().describe("Additional context about the code")
 };
 async function handleCodeReview(client2, input) {
   const { code, language, context } = input;
@@ -541,12 +1119,12 @@ ${context}` : ""}` : context;
 }
 
 // src/tools/review-frontend.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var frontendReviewSchema = {
-  code: z3.string().describe("The frontend code to review"),
-  framework: z3.string().optional().describe("Frontend framework (e.g., react, vue, svelte)"),
-  review_type: z3.enum(["accessibility", "performance", "ux", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z3.string().optional().describe("Additional context")
+  code: z4.string().describe("The frontend code to review"),
+  framework: z4.string().optional().describe("Frontend framework (e.g., react, vue, svelte)"),
+  review_type: z4.enum(["accessibility", "performance", "ux", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z4.string().optional().describe("Additional context")
 };
 async function handleFrontendReview(client2, input) {
   const { code, framework, review_type, context } = input;
@@ -570,13 +1148,13 @@ async function handleFrontendReview(client2, input) {
 
 // src/tools/review-git.ts
 import { execSync } from "child_process";
-import { z as z4 } from "zod";
-var gitReviewSchemaObj = z4.object({
-  review_type: z4.enum(["staged", "unstaged", "diff", "commit"]).optional().describe(
+import { z as z5 } from "zod";
+var gitReviewSchemaObj = z5.object({
+  review_type: z5.enum(["staged", "unstaged", "diff", "commit"]).optional().describe(
     "Type of changes to review: 'staged' (git diff --cached), 'unstaged' (git diff), 'diff' (git diff main..HEAD), 'commit' (specific commit). Default: staged"
   ),
-  commit_hash: z4.string().optional().describe("Commit hash to review (only used when review_type is 'commit')"),
-  context: z4.string().optional().describe("Additional context about the changes")
+  commit_hash: z5.string().optional().describe("Commit hash to review (only used when review_type is 'commit')"),
+  context: z5.string().optional().describe("Additional context about the changes")
 });
 var gitReviewSchema = gitReviewSchemaObj.shape;
 function getGitDiff(reviewType = "staged", commitHash) {
@@ -637,11 +1215,11 @@ async function handleGitReview(client2, models, input) {
 }
 
 // src/tools/review-plan.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var planReviewSchema = {
-  plan: z5.string().describe("The implementation plan to review"),
-  review_type: z5.enum(["feasibility", "completeness", "risks", "timeline", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z5.string().optional().describe("Additional context about the project or constraints")
+  plan: z6.string().describe("The implementation plan to review"),
+  review_type: z6.enum(["feasibility", "completeness", "risks", "timeline", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z6.string().optional().describe("Additional context about the project or constraints")
 };
 async function handlePlanReview(client2, input) {
   const { plan, review_type, context } = input;
@@ -674,6 +1252,7 @@ if (!OPENROUTER_API_KEY) {
   process.exit(1);
 }
 var client = new ReviewClient(OPENROUTER_API_KEY);
+var sessionStore = new InMemorySessionStore();
 var server = new McpServer({
   name: "code-council",
   version: "1.0.0"
@@ -718,6 +1297,23 @@ server.registerTool(
     };
   }
 );
+createConversationTool(
+  server,
+  {
+    name: "discuss_with_council",
+    description: "Start or continue a multi-turn discussion with the AI council. First call (without session_id) starts a new discussion and returns a session_id. Subsequent calls with the session_id continue the conversation. Each model maintains its own conversation history for authentic perspectives.",
+    inputSchema: discussCouncilSchema,
+    handler: (input, store) => handleDiscussCouncil(client, input, store)
+  },
+  sessionStore
+);
+function handleShutdown(signal) {
+  logger.info(`Received ${signal}, shutting down gracefully`);
+  sessionStore.shutdown();
+  process.exit(0);
+}
+process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+process.on("SIGINT", () => handleShutdown("SIGINT"));
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -725,7 +1321,8 @@ async function main() {
     codeReviewModels: CODE_REVIEW_MODELS,
     frontendReviewModels: FRONTEND_REVIEW_MODELS,
     backendReviewModels: BACKEND_REVIEW_MODELS,
-    planReviewModels: PLAN_REVIEW_MODELS
+    planReviewModels: PLAN_REVIEW_MODELS,
+    discussionModels: DISCUSSION_MODELS
   });
 }
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@klitchevo/code-council",
-	"version": "0.0.8",
+	"version": "0.0.11",
 	"description": "Multi-model AI code review server using OpenRouter - get diverse perspectives from multiple LLMs in parallel",
 	"main": "dist/index.js",
 	"type": "module",