deepthinking-mcp 2.5.3 → 2.5.5

package/dist/index.js

@@ -2,7 +2,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -991,8 +991,399 @@ var ModeRecommender = class {
   }
 };
 
-// src/session/manager.ts
+// src/utils/errors.ts
+var DeepThinkingError = class extends Error {
+  code;
+  context;
+  timestamp;
+  constructor(message, code, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.context = context;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert error to JSON for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack
+    };
+  }
+};
+var SessionError = class extends DeepThinkingError {
+  constructor(message, context) {
+    super(message, "SESSION_ERROR", context);
+  }
+};
+var SessionNotFoundError = class extends SessionError {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`, { sessionId });
+    this.code = "SESSION_NOT_FOUND";
+  }
+};
+
+// src/utils/sanitization.ts
+var MAX_LENGTHS = {
+  THOUGHT_CONTENT: 1e5,
+  // 100KB for thought content
+  TITLE: 500,
+  DOMAIN: 200,
+  AUTHOR: 300,
+  STRING_FIELD: 1e3
+};
+function sanitizeString(input, maxLength = MAX_LENGTHS.STRING_FIELD, fieldName = "input") {
+  if (typeof input !== "string") {
+    throw new Error(`${fieldName} must be a string`);
+  }
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${fieldName} cannot be empty`);
+  }
+  if (trimmed.length > maxLength) {
+    throw new Error(`${fieldName} exceeds maximum length of ${maxLength} characters`);
+  }
+  if (trimmed.includes("\0")) {
+    throw new Error(`${fieldName} contains invalid null bytes`);
+  }
+  return trimmed;
+}
+function validateSessionId(sessionId) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  if (!uuidRegex.test(sessionId)) {
+    throw new Error(`Invalid session ID format: ${sessionId}`);
+  }
+  return sessionId;
+}
+function sanitizeThoughtContent(content) {
+  return sanitizeString(content, MAX_LENGTHS.THOUGHT_CONTENT, "thought content");
+}
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
 var DEFAULT_CONFIG = {
+  minLevel: 1 /* INFO */,
+  enableConsole: true,
+  enableTimestamps: true,
+  prettyPrint: true
+};
+var Logger = class {
+  config;
+  logs = [];
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, context) {
+    this.log(0 /* DEBUG */, message, context);
+  }
+  /**
+   * Log an info message
+   */
+  info(message, context) {
+    this.log(1 /* INFO */, message, context);
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, context) {
+    this.log(2 /* WARN */, message, context);
+  }
+  /**
+   * Log an error message
+   */
+  error(message, error, context) {
+    this.log(3 /* ERROR */, message, context, error);
+  }
+  /**
+   * Internal log method
+   */
+  log(level, message, context, error) {
+    if (level < this.config.minLevel) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      context,
+      error
+    };
+    this.logs.push(entry);
+    if (this.config.enableConsole) {
+      this.writeToConsole(entry);
+    }
+  }
+  /**
+   * Write log entry to console
+   */
+  writeToConsole(entry) {
+    const levelName = LogLevel[entry.level];
+    const timestamp = this.config.enableTimestamps ? `[${entry.timestamp.toISOString()}] ` : "";
+    let message = `${timestamp}${levelName}: ${entry.message}`;
+    if (entry.context && this.config.prettyPrint) {
+      message += `
+  Context: ${JSON.stringify(entry.context, null, 2)}`;
+    }
+    if (entry.error) {
+      message += `
+  Error: ${entry.error.message}`;
+      if (entry.error.stack && this.config.prettyPrint) {
+        message += `
+  Stack: ${entry.error.stack}`;
+      }
+    }
+    switch (entry.level) {
+      case 0 /* DEBUG */:
+      case 1 /* INFO */:
+        console.log(message);
+        break;
+      case 2 /* WARN */:
+        console.warn(message);
+        break;
+      case 3 /* ERROR */:
+        console.error(message);
+        break;
+    }
+  }
+  /**
+   * Get all log entries
+   */
+  getLogs(minLevel) {
+    if (minLevel !== void 0) {
+      return this.logs.filter((log) => log.level >= minLevel);
+    }
+    return [...this.logs];
+  }
+  /**
+   * Clear all logs
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+  /**
+   * Set minimum log level
+   */
+  setLevel(level) {
+    this.config.minLevel = level;
+  }
+  /**
+   * Export logs as JSON
+   */
+  exportLogs() {
+    return JSON.stringify(this.logs.map((log) => ({
+      ...log,
+      level: LogLevel[log.level],
+      timestamp: log.timestamp.toISOString()
+    })), null, 2);
+  }
+};
+new Logger();
+function createLogger(config) {
+  return new Logger(config);
+}
+
+// src/config/index.ts
+var defaultConfig = {
+  maxThoughtsInMemory: parseInt(process.env.MCP_MAX_THOUGHTS || "1000", 10),
+  compressionThreshold: parseInt(process.env.MCP_COMPRESSION_THRESHOLD || "500", 10),
+  maxContentLength: parseInt(process.env.MCP_MAX_CONTENT_LENGTH || "10000", 10),
+  validationTolerance: parseFloat(process.env.MCP_VALIDATION_TOLERANCE || "0.01"),
+  maxActiveSessions: parseInt(process.env.MCP_MAX_SESSIONS || "100", 10),
+  sessionTimeoutMs: parseInt(process.env.MCP_SESSION_TIMEOUT_MS || "0", 10),
+  enableValidationCache: process.env.MCP_ENABLE_VALIDATION_CACHE !== "false",
+  validationCacheMaxSize: parseInt(process.env.MCP_VALIDATION_CACHE_SIZE || "1000", 10),
+  enablePersistence: process.env.MCP_ENABLE_PERSISTENCE === "true",
+  persistenceDir: process.env.MCP_PERSISTENCE_DIR || "./.deepthinking-sessions",
+  logLevel: process.env.MCP_LOG_LEVEL || "info",
+  enablePerformanceMetrics: process.env.MCP_ENABLE_PERF_METRICS === "true"
+};
+var activeConfig = { ...defaultConfig };
+function getConfig() {
+  return Object.freeze({ ...activeConfig });
+}
+function validateConfig(config) {
+  if (config.maxThoughtsInMemory < 1) {
+    throw new Error("maxThoughtsInMemory must be at least 1");
+  }
+  if (config.compressionThreshold < 0) {
+    throw new Error("compressionThreshold must be non-negative");
+  }
+  if (config.maxContentLength < 1) {
+    throw new Error("maxContentLength must be at least 1");
+  }
+  if (config.validationTolerance < 0 || config.validationTolerance > 1) {
+    throw new Error("validationTolerance must be between 0 and 1");
+  }
+  if (config.maxActiveSessions < 1) {
+    throw new Error("maxActiveSessions must be at least 1");
+  }
+  if (config.sessionTimeoutMs < 0) {
+    throw new Error("sessionTimeoutMs must be non-negative");
+  }
+  if (config.validationCacheMaxSize < 0) {
+    throw new Error("validationCacheMaxSize must be non-negative");
+  }
+  if (!["debug", "info", "warn", "error"].includes(config.logLevel)) {
+    throw new Error("logLevel must be one of: debug, info, warn, error");
+  }
+}
+validateConfig(activeConfig);
+var ValidationCache = class {
+  cache;
+  maxSize;
+  hits = 0;
+  misses = 0;
+  constructor(maxSize) {
+    const config = getConfig();
+    this.maxSize = maxSize || config.validationCacheMaxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Generate a cache key from thought content
+   *
+   * Uses SHA-256 hash of JSON-serialized content for reliable cache keys
+   *
+   * @param content - Content to hash
+   * @returns Cache key
+   */
+  generateKey(content) {
+    const json = JSON.stringify(content);
+    return createHash("sha256").update(json).digest("hex");
+  }
+  /**
+   * Get validation result from cache
+   *
+   * @param content - Content to look up
+   * @returns Cached result or undefined if not found
+   */
+  get(content) {
+    const key = this.generateKey(content);
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.hits++;
+      entry.hitCount++;
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+      return entry;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Store validation result in cache
+   *
+   * @param content - Content that was validated
+   * @param result - Validation result to cache
+   */
+  set(content, result) {
+    const key = this.generateKey(content);
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    const entry = {
+      result,
+      timestamp: Date.now(),
+      hitCount: 0
+    };
+    this.cache.set(key, entry);
+  }
+  /**
+   * Check if content is in cache
+   *
+   * @param content - Content to check
+   * @returns true if cached
+   */
+  has(content) {
+    const key = this.generateKey(content);
+    return this.cache.has(key);
+  }
+  /**
+   * Clear all cached validation results
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+  /**
+   * Resize the cache
+   *
+   * @param newSize - New maximum cache size
+   */
+  resize(newSize) {
+    this.maxSize = newSize;
+    if (this.cache.size > newSize) {
+      const keysToDelete = this.cache.size - newSize;
+      const keys = Array.from(this.cache.keys());
+      for (let i = 0; i < keysToDelete; i++) {
+        this.cache.delete(keys[i]);
+      }
+    }
+  }
+  /**
+   * Get entries sorted by hit count (most used first)
+   */
+  getTopEntries(limit = 10) {
+    const entries = Array.from(this.cache.entries()).map(([key, entry]) => ({ key, entry })).sort((a, b) => b.entry.hitCount - a.entry.hitCount);
+    return entries.slice(0, limit);
+  }
+  /**
+   * Remove entries older than a certain age
+   *
+   * @param maxAgeMs - Maximum age in milliseconds
+   * @returns Number of entries removed
+   */
+  evictOld(maxAgeMs) {
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > maxAgeMs) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+};
+var validationCache = new ValidationCache();
+
+// src/session/manager.ts
+var DEFAULT_CONFIG2 = {
   modeConfig: {
     mode: "hybrid" /* HYBRID */,
     strictValidation: false,
@@ -1010,48 +1401,139 @@ var DEFAULT_CONFIG = {
 var SessionManager = class {
   activeSessions;
   config;
-  constructor(config) {
+  logger;
+  /**
+   * Creates a new SessionManager instance
+   *
+   * @param config - Optional default configuration applied to all new sessions
+   * @param logLevel - Optional minimum log level (default: INFO)
+   *
+   * @example
+   * ```typescript
+   * const manager = new SessionManager({
+   *   enableAutoSave: true,
+   *   maxThoughtsInMemory: 500
+   * }, LogLevel.DEBUG);
+   * ```
+   */
+  constructor(config, logLevel) {
     this.activeSessions = /* @__PURE__ */ new Map();
     this.config = config || {};
+    this.logger = createLogger({
+      minLevel: logLevel || 1 /* INFO */,
+      enableConsole: true
+    });
   }
   /**
    * Create a new thinking session
+   *
+   * Creates and initializes a new thinking session with the specified configuration.
+   * Sessions are stored in memory and tracked until explicitly deleted.
+   *
+   * @param options - Session creation options
+   * @param options.title - Session title (default: 'Untitled Session')
+   * @param options.mode - Thinking mode to use (default: HYBRID)
+   * @param options.domain - Problem domain (e.g., 'mathematics', 'physics')
+   * @param options.author - Session creator/author
+   * @param options.config - Session-specific configuration overrides
+   * @returns Promise resolving to the created session
+   *
+   * @example
+   * ```typescript
+   * const session = await manager.createSession({
+   *   title: 'Mathematical Proof',
+   *   mode: ThinkingMode.MATHEMATICS,
+   *   domain: 'number-theory',
+   *   author: 'user@example.com'
+   * });
+   * ```
    */
   async createSession(options = {}) {
+    const title = options.title ? sanitizeString(options.title, MAX_LENGTHS.TITLE, "title") : "Untitled Session";
+    const domain = options.domain ? sanitizeString(options.domain, MAX_LENGTHS.DOMAIN, "domain") : void 0;
+    const author = options.author ? sanitizeString(options.author, MAX_LENGTHS.AUTHOR, "author") : void 0;
     const sessionId = randomUUID();
     const now = /* @__PURE__ */ new Date();
     const session = {
       id: sessionId,
-      title: options.title || "Untitled Session",
+      title,
       mode: options.mode || "hybrid" /* HYBRID */,
-      domain: options.domain,
+      domain,
       config: this.mergeConfig(options.config),
       thoughts: [],
       createdAt: now,
       updatedAt: now,
-      author: options.author,
+      author,
       currentThoughtNumber: 0,
       isComplete: false,
       metrics: this.initializeMetrics(),
       tags: [],
-      collaborators: options.author ? [options.author] : []
+      collaborators: author ? [author] : []
     };
     this.activeSessions.set(sessionId, session);
+    this.logger.info("Session created", {
+      sessionId,
+      title,
+      mode: session.mode,
+      domain,
+      author
+    });
     return session;
   }
   /**
    * Get a session by ID
+   *
+   * Retrieves an active session by its unique identifier.
+   *
+   * @param sessionId - Unique UUID v4 identifier of the session
+   * @returns Promise resolving to the session, or null if not found
+   *
+   * @example
+   * ```typescript
+   * const session = await manager.getSession('550e8400-e29b-41d4-a716-446655440000');
+   * if (session) {
+   *   console.log(`Session: ${session.title}`);
+   *   console.log(`Thoughts: ${session.thoughts.length}`);
+   * }
+   * ```
    */
   async getSession(sessionId) {
     return this.activeSessions.get(sessionId) || null;
   }
   /**
    * Add a thought to a session
+   *
+   * Adds a new thought to an existing session and automatically updates:
+   * - Session metrics (uses O(1) incremental calculation)
+   * - Thought timestamps
+   * - Session completion status
+   * - Mode-specific analytics
+   *
+   * @param sessionId - ID of the session to add thought to
+   * @param thought - The thought object to add
+   * @returns Promise resolving to the updated session
+   * @throws Error if session is not found
+   *
+   * @example
+   * ```typescript
+   * await manager.addThought(session.id, {
+   *   thought: 'Initial hypothesis: the problem can be solved using...',
+   *   thoughtNumber: 1,
+   *   totalThoughts: 5,
+   *   nextThoughtNeeded: true,
+   *   uncertainty: 0.3
+   * });
+   * ```
    */
   async addThought(sessionId, thought) {
+    validateSessionId(sessionId);
     const session = this.activeSessions.get(sessionId);
     if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
+      this.logger.error("Session not found", void 0, { sessionId });
+      throw new SessionNotFoundError(sessionId);
+    }
+    if (thought.content) {
+      thought.content = sanitizeThoughtContent(thought.content);
     }
     thought.sessionId = sessionId;
     thought.timestamp = /* @__PURE__ */ new Date();
@@ -1061,25 +1543,74 @@ var SessionManager = class {
     this.updateMetrics(session, thought);
     if (!thought.nextThoughtNeeded) {
       session.isComplete = true;
+      this.logger.info("Session completed", {
+        sessionId,
+        title: session.title,
+        totalThoughts: session.thoughts.length
+      });
     }
+    this.logger.debug("Thought added", {
+      sessionId,
+      thoughtNumber: thought.thoughtNumber,
+      totalThoughts: session.thoughts.length
+    });
     return session;
   }
   /**
-   * Update session mode
+   * Update session mode (switch reasoning approach mid-session)
+   *
+   * Changes the thinking mode of an active session. This is useful when
+   * the problem requires a different reasoning approach.
+   *
+   * @param sessionId - ID of the session to update
+   * @param newMode - New thinking mode to switch to
+   * @param reason - Optional reason for the mode switch
+   * @returns Promise resolving to the updated session
+   * @throws Error if session is not found
+   *
+   * @example
+   * ```typescript
+   * await manager.switchMode(
+   *   session.id,
+   *   ThinkingMode.CAUSAL,
+   *   'Need to analyze cause-effect relationships'
+   * );
+   * ```
    */
   async switchMode(sessionId, newMode, reason) {
+    validateSessionId(sessionId);
     const session = this.activeSessions.get(sessionId);
     if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
+      this.logger.error("Session not found", void 0, { sessionId });
+      throw new SessionNotFoundError(sessionId);
     }
-    session.mode;
+    const oldMode = session.mode;
     session.mode = newMode;
     session.config.modeConfig.mode = newMode;
     session.updatedAt = /* @__PURE__ */ new Date();
+    this.logger.info("Session mode switched", {
+      sessionId,
+      oldMode,
+      newMode,
+      reason
+    });
     return session;
   }
   /**
-   * List all sessions
+   * List all active sessions with metadata
+   *
+   * Returns summary information for all sessions currently managed
+   * by this SessionManager instance.
+   *
+   * @returns Promise resolving to array of session metadata
+   *
+   * @example
+   * ```typescript
+   * const sessions = await manager.listSessions();
+   * sessions.forEach(s => {
+   *   console.log(`${s.title}: ${s.thoughtCount} thoughts (${s.mode})`);
+   * });
+   * ```
    */
   async listSessions() {
     return Array.from(this.activeSessions.values()).map((session) => ({
@@ -1094,17 +1625,59 @@ var SessionManager = class {
   }
   /**
    * Delete a session
+   *
+   * Removes a session from memory. This operation cannot be undone.
+   *
+   * @param sessionId - ID of the session to delete
+   * @returns Promise that resolves when deletion is complete
+   *
+   * @example
+   * ```typescript
+   * await manager.deleteSession('old-session-id');
+   * ```
    */
   async deleteSession(sessionId) {
-    this.activeSessions.delete(sessionId);
+    const session = this.activeSessions.get(sessionId);
+    const deleted = this.activeSessions.delete(sessionId);
+    if (deleted && session) {
+      this.logger.info("Session deleted", {
+        sessionId,
+        title: session.title,
+        thoughtCount: session.thoughts.length
+      });
+    } else {
+      this.logger.warn("Attempted to delete non-existent session", { sessionId });
+    }
   }
   /**
-   * Generate summary of session
+   * Generate a text summary of a session
+   *
+   * Creates a markdown-formatted summary including:
+   * - Session metadata (title, mode, status)
+   * - Total thought count
+   * - Key thoughts (first 100 characters of each)
+   *
+   * @param sessionId - ID of the session to summarize
+   * @returns Promise resolving to markdown-formatted summary
+   * @throws Error if session is not found
+   *
+   * @example
+   * ```typescript
+   * const summary = await manager.generateSummary(session.id);
+   * console.log(summary);
+   * // Output:
+   * // # Mathematical Proof
+   * // Mode: mathematics
+   * // Total Thoughts: 15
+   * // Status: Complete
+   * // ...
+   * ```
    */
   async generateSummary(sessionId) {
+    validateSessionId(sessionId);
     const session = this.activeSessions.get(sessionId);
     if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
+      throw new SessionNotFoundError(sessionId);
     }
     let summary = `# ${session.title}
 
@@ -1126,17 +1699,22 @@ var SessionManager = class {
     return summary;
   }
   /**
-   * Merge configurations
+   * Merge configurations (private helper)
+   *
+   * Combines default config, instance config, and user config
+   * with proper precedence: user > instance > default
    */
   mergeConfig(userConfig) {
     return {
-      ...DEFAULT_CONFIG,
+      ...DEFAULT_CONFIG2,
       ...this.config,
       ...userConfig
     };
   }
   /**
-   * Initialize metrics
+   * Initialize metrics (private helper)
+   *
+   * Creates a fresh SessionMetrics object with zero values
    */
   initializeMetrics() {
     return {
@@ -1146,15 +1724,30 @@ var SessionManager = class {
       revisionCount: 0,
       timeSpent: 0,
       dependencyDepth: 0,
-      customMetrics: /* @__PURE__ */ new Map()
+      customMetrics: /* @__PURE__ */ new Map(),
+      cacheStats: {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        size: 0,
+        maxSize: 0
+      }
     };
   }
   /**
-   * Update session metrics
+   * Update session metrics (private helper)
+   *
+   * Incrementally updates metrics using O(1) algorithms for performance.
+   * Handles mode-specific metrics for temporal, game theory, and evidential modes.
+   *
+   * @param session - Session to update
+   * @param thought - Newly added thought
    */
   updateMetrics(session, thought) {
     const metrics = session.metrics;
     metrics.totalThoughts = session.thoughts.length;
+    const thoughtType = thought.type || "unknown";
+    metrics.thoughtsByType[thoughtType] = (metrics.thoughtsByType[thoughtType] || 0) + 1;
     if (thought.isRevision) {
       metrics.revisionCount++;
     }
@@ -1235,6 +1828,22 @@ var SessionManager = class {
         metrics.customMetrics.set("decisions", thought.decisions.length);
       }
     }
+    this.updateCacheStats(session);
+  }
+  /**
+   * Update validation cache statistics in session metrics
+   *
+   * @param session - Session to update
+   */
+  updateCacheStats(session) {
+    const cacheStats = validationCache.getStats();
+    session.metrics.cacheStats = {
+      hits: cacheStats.hits,
+      misses: cacheStats.misses,
+      hitRate: cacheStats.hitRate,
+      size: cacheStats.size,
+      maxSize: cacheStats.maxSize
+    };
   }
 };
 
@@ -1682,6 +2291,52 @@ Bayes Factor: ${thought.bayesFactor.toFixed(2)}
   }
 };
 
+// src/utils/type-guards.ts
+var VALID_THOUGHT_TYPES = [
+  "problem_definition",
+  "constraints",
+  "model",
+  "proof",
+  "implementation",
+  "axiom_definition",
+  "theorem_statement",
+  "proof_construction",
+  "lemma_derivation",
+  "corollary",
+  "counterexample",
+  "algebraic_manipulation",
+  "symbolic_computation",
+  "numerical_analysis",
+  "symmetry_analysis",
+  "gauge_theory",
+  "field_equations",
+  "lagrangian",
+  "hamiltonian",
+  "conservation_law",
+  "dimensional_analysis",
+  "tensor_formulation",
+  "differential_geometry",
+  "decomposition",
+  "synthesis",
+  "abstraction",
+  "analogy",
+  "metacognition"
+];
+function isExtendedThoughtType(value) {
+  return typeof value === "string" && VALID_THOUGHT_TYPES.includes(value);
+}
+function toExtendedThoughtType(value, fallback) {
+  if (isExtendedThoughtType(value)) {
+    return value;
+  }
+  if (fallback !== void 0) {
+    return fallback;
+  }
+  throw new Error(
+    `Invalid ExtendedThoughtType: ${value}. Must be one of: ${VALID_THOUGHT_TYPES.join(", ")}`
+  );
+}
+
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
@@ -1948,7 +2603,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "mathematics" /* MATHEMATICS */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "model"),
         mathematicalModel: input.mathematicalModel,
         proofStrategy: input.proofStrategy,
         dependencies: input.dependencies || [],
@@ -1959,7 +2614,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "physics" /* PHYSICS */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "model"),
         tensorProperties: input.tensorProperties,
         physicalInterpretation: input.physicalInterpretation,
         dependencies: input.dependencies || [],
@@ -1970,7 +2625,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "abductive" /* ABDUCTIVE */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         observations: input.observations || [],
         hypotheses: input.hypotheses || [],
         evaluationCriteria: input.evaluationCriteria,
@@ -1981,7 +2636,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "causal" /* CAUSAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         causalGraph: input.causalGraph,
         interventions: input.interventions || [],
         mechanisms: input.mechanisms || [],
@@ -1991,7 +2646,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "bayesian" /* BAYESIAN */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         hypothesis: input.hypothesis,
         prior: input.prior,
         likelihood: input.likelihood,
@@ -2003,7 +2658,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "counterfactual" /* COUNTERFACTUAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         actual: input.actual,
         counterfactuals: input.counterfactuals || [],
         comparison: input.comparison,
@@ -2014,7 +2669,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "analogical" /* ANALOGICAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "analogy"),
         sourceDomain: input.sourceDomain,
         targetDomain: input.targetDomain,
         mapping: input.mapping || [],
@@ -2027,7 +2682,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "temporal" /* TEMPORAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "event_definition",
         timeline: input.timeline,
         events: input.events || [],
         intervals: input.intervals || [],
@@ -2038,7 +2693,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "gametheory" /* GAMETHEORY */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "game_definition",
         game: input.game,
         players: input.players || [],
         strategies: input.strategies || [],
@@ -2051,7 +2706,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "evidential" /* EVIDENTIAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "hypothesis_definition",
         frameOfDiscernment: input.frameOfDiscernment,
         hypotheses: input.hypotheses || [],
         evidence: input.evidence || [],
@@ -2065,7 +2720,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "hybrid" /* HYBRID */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "synthesis"),
         stage: input.stage,
         uncertainty: input.uncertainty,
         dependencies: input.dependencies,
@@ -2073,7 +2728,7 @@ function createThought(input, sessionId) {
         mathematicalModel: input.mathematicalModel,
         tensorProperties: input.tensorProperties,
         physicalInterpretation: input.physicalInterpretation,
-        primaryMode: input.mode,
+        primaryMode: input.mode || "hybrid" /* HYBRID */,
         secondaryFeatures: []
       };
   }