Think MCP

Instructions

Implementation Reference

• src/index.ts:232-275 (handler)

  MCP tool handler for 'think_done': processes input args, calls thinkingService.consolidate for path verification and issue detection, formats output with status/READY or BLOCKED, progress metrics, warnings; optionally appends exported session report.
  server.registerTool('think_done', { title: 'Think Done', description: THINK_DONE_DESCRIPTION, inputSchema: thinkDoneSchema }, async (args) => { try { const result = thinkingService.consolidate({ winningPath: args.winningPath as number[], summary: args.summary as string, constraintCheck: args.constraintCheck as string | undefined, potentialFlaws: args.potentialFlaws as string | undefined, verdict: args.verdict as 'ready' | 'needs_more_work', }); if (result.status === 'error') { return { content: [{ type: 'text' as const, text: `Error: ${result.errorMessage}` }], isError: true }; } const pa = result.pathAnalysis; const issues = [ pa.lowConfidenceInPath.length > 0 ? `lowConf:#${pa.lowConfidenceInPath.join(',')}` : '', pa.unaddressedBlockers.length > 0 ? `blockers:#${pa.unaddressedBlockers.join(',')}` : '', ].filter(Boolean).join(' | '); let text = [ result.canProceedToFinalAnswer ? '✅ READY' : '🛑 BLOCKED', `📊 Path: ${pa.pathLength}/${pa.totalThoughts} (${Math.round(pa.ignoredRatio * 100)}% ignored)`, issues ? `⚠️ ${issues}` : '', '', '--- STATUS ---', `verdict: ${result.canProceedToFinalAnswer ? 'READY' : 'BLOCKED'}`, ].filter(Boolean).join('\n'); // Export if requested (merged from export_session) if (args.exportReport) { const report = thinkingService.exportSession({ format: args.exportReport as 'markdown' | 'json', includeMermaid: (args.includeMermaid as boolean) ?? true, }); text += '\n\n--- EXPORT ---\n' + report; } return { content: [{ type: 'text' as const, text }] }; } catch (error) { return { content: [{ type: 'text' as const, text: `Error: ${error instanceof Error ? error.message : 'Unknown'}` }], isError: true }; } }
• src/index.ts:222-230 (schema)

  Zod input schema for 'think_done' tool, defining required winningPath, summary, verdict and optional fields for checks and export.
  const thinkDoneSchema = { winningPath: z.array(z.number().int().min(1)).describe('Thought numbers leading to solution'), summary: z.string().describe('Final logic summary'), verdict: z.enum(['ready', 'needs_more_work']).describe('Ready for answer?'), constraintCheck: z.string().optional().describe('How constraints were addressed'), potentialFlaws: z.string().optional().describe('What could go wrong'), exportReport: z.enum(['markdown', 'json']).optional().describe('Export format (optional)'), includeMermaid: z.boolean().optional().describe('Include diagram in export'), };
• src/index.ts:232-232 (registration)

  Registration of 'think_done' tool with McpServer, including title, description, and inputSchema.
  server.registerTool('think_done', { title: 'Think Done', description: THINK_DONE_DESCRIPTION, inputSchema: thinkDoneSchema },
• src/services/consolidate.service.ts:25-232 (helper)

  ConsolidateService.consolidate(): Primary helper implementing think_done logic - validates winning path connectivity, detects low-confidence thoughts in path, unaddressed blockers/critical extensions, high ignored ratio, path discontinuities; computes canProceedToFinalAnswer and pathAnalysis.
  consolidate( input: ConsolidateInput, sessionThoughts: ThoughtRecord[], onDeadEnd?: (path: number[], reason: string) => void, onSuccess?: (path: number[], summary: string) => void ): ConsolidateResult { const { winningPath, verdict } = input; const warnings: string[] = []; // Validate: must have thoughts to consolidate if (sessionThoughts.length === 0) { return { status: 'error', evaluation: 'Cannot consolidate empty thought history.', warnings: [], canProceedToFinalAnswer: false, pathAnalysis: { totalThoughts: 0, pathLength: 0, ignoredRatio: 0, lowConfidenceInPath: [], unaddressedBlockers: [], unaddressedCritical: [], }, errorMessage: 'No thoughts recorded. Use sequentialthinking first.', }; } // Validate: winning path must reference existing thoughts in current session const existingNumbers = new Set(sessionThoughts.map((t) => t.thoughtNumber)); const invalidRefs = winningPath.filter((n) => !existingNumbers.has(n)); if (invalidRefs.length > 0) { return { status: 'error', evaluation: `Invalid thought references in winning path: ${invalidRefs.join(', ')}`, warnings: [], canProceedToFinalAnswer: false, pathAnalysis: { totalThoughts: sessionThoughts.length, pathLength: winningPath.length, ignoredRatio: 0, lowConfidenceInPath: [], unaddressedBlockers: [], unaddressedCritical: [], }, errorMessage: `Thoughts ${invalidRefs.join(', ')} do not exist in current session.`, }; } // Validate: path connectivity - thoughts must be logically connected const connectivityCheck = this.validationService.validatePathConnectivity( winningPath, sessionThoughts ); if (!connectivityCheck.valid) { warnings.push(`🚫 PATH DISCONTINUITY: ${connectivityCheck.error}`); } // Find low-confidence thoughts in winning path const lowConfidenceInPath = sessionThoughts .filter((t) => winningPath.includes(t.thoughtNumber)) .filter((t) => t.confidence !== undefined && t.confidence < 5) .map((t) => t.thoughtNumber); if (lowConfidenceInPath.length > 0) { warnings.push( `⚠️ LOW CONFIDENCE: Your winning path includes thoughts with confidence < 5: #${lowConfidenceInPath.join(', ')}. Are you sure about these steps?` ); } // Check ignored thoughts ratio const ignoredRatio = 1 - winningPath.length / sessionThoughts.length; if (ignoredRatio > 0.6) { warnings.push( `⚠️ HIGH DISCARD RATE: You are ignoring ${Math.round(ignoredRatio * 100)}% of your thoughts. Ensure you haven't missed important contradictions in discarded branches.` ); } // Find unaddressed BLOCKER and HIGH impact critique extensions const unaddressedBlockers: number[] = []; const unaddressedCritical: number[] = []; for (const thought of sessionThoughts) { if (thought.extensions) { const hasBlocker = thought.extensions.some((e) => e.impact === 'blocker'); const hasHighCritique = thought.extensions.some( (e) => e.impact === 'high' && e.type === 'critique' ); if (winningPath.includes(thought.thoughtNumber)) { const hasRevision = sessionThoughts.some( (t) => t.isRevision && t.revisesThought === thought.thoughtNumber ); if (hasBlocker && !hasRevision) { unaddressedBlockers.push(thought.thoughtNumber); } if (hasHighCritique && !hasRevision) { unaddressedCritical.push(thought.thoughtNumber); } } } } if (unaddressedBlockers.length > 0) { warnings.push( `🚫 UNADDRESSED BLOCKERS: Thoughts #${unaddressedBlockers.join(', ')} have BLOCKER extensions but no revisions. You MUST address these before proceeding.` ); } if (unaddressedCritical.length > 0) { warnings.push( `⚠️ UNADDRESSED CRITICAL: Thoughts #${unaddressedCritical.join(', ')} have HIGH impact critiques but no revisions. Address these issues with isRevision: true.` ); } // Check for missing revisions in winningPath const missingRevisions: number[] = []; for (const thought of sessionThoughts) { if (!winningPath.includes(thought.thoughtNumber)) continue; if (!thought.extensions) continue; const hasCritical = thought.extensions.some( (e) => (e.impact === 'high' || e.impact === 'blocker') && e.type === 'critique' ); if (!hasCritical) continue; const revision = sessionThoughts.find( (t) => t.isRevision && t.revisesThought === thought.thoughtNumber ); if (revision && !winningPath.includes(revision.thoughtNumber)) { missingRevisions.push(thought.thoughtNumber); } } if (missingRevisions.length > 0) { warnings.push( `🚫 MISSING REVISIONS IN PATH: Thoughts #${missingRevisions.join(', ')} have critical critiques with revisions, but those revisions are NOT in your winningPath. Include the revision thoughts or remove the flawed originals.` ); } // Check for empty or too short winning path if (winningPath.length === 0) { warnings.push('⚠️ EMPTY PATH: No thoughts selected in winning path. This seems wrong.'); } else if (winningPath.length < 2 && sessionThoughts.length > 3) { warnings.push( '⚠️ SUSPICIOUSLY SHORT PATH: Only 1 thought selected from a longer chain. Did you skip important reasoning?' ); } // Determine if can proceed const hasBlockerWarnings = unaddressedBlockers.length > 0; const hasCriticalWarnings = unaddressedCritical.length > 0; const hasMissingRevisions = missingRevisions.length > 0; const hasPathDiscontinuity = !connectivityCheck.valid; const canProceed = verdict === 'ready' && !hasBlockerWarnings && !hasCriticalWarnings && !hasMissingRevisions && !hasPathDiscontinuity && warnings.length <= 1; // Generate evaluation message let evaluation: string; if (canProceed) { evaluation = '✅ SYNTHESIS ACCEPTED: Your reasoning chain is coherent. You may proceed to final answer.'; // v4.1.0: Save insight via callback on successful consolidation if (onSuccess) { onSuccess(winningPath, input.summary); } } else if (verdict === 'needs_more_work') { evaluation = '🔄 ACKNOWLEDGED: You identified this needs more work. Continue with sequentialthinking or extend_thought.'; // Record dead end via callback if (onDeadEnd) { onDeadEnd(winningPath, input.summary); } } else { evaluation = `⚠️ SYNTHESIS REJECTED: ${warnings.length} issue(s) found. Address them before providing final answer.`; } // Log consolidation console.error( `🎯 Consolidation: verdict=${verdict}, path=[${winningPath.join(',')}], warnings=${warnings.length}, canProceed=${canProceed}` ); return { status: 'success', evaluation, warnings, canProceedToFinalAnswer: canProceed, pathAnalysis: { totalThoughts: sessionThoughts.length, pathLength: winningPath.length, ignoredRatio: Math.round(ignoredRatio * 100) / 100, lowConfidenceInPath, unaddressedBlockers, unaddressedCritical, disconnectedAt: connectivityCheck.disconnectedAt ? [connectivityCheck.disconnectedAt] : undefined, }, }; }
• src/services/export.service.ts:30-57 (helper)

  ExportService.export(): Generates Markdown or JSON session reports including thoughts, extensions, branches, dead ends, Mermaid diagram; invoked optionally in think_done handler.
  export(data: ExportSessionData, options: ExportOptions = {}): string { const { format = 'markdown', includeMermaid = true } = options; const { thoughts, branches, deadEnds, sessionGoal, averageConfidence, mermaidDiagram } = data; if (thoughts.length === 0) { return format === 'json' ? JSON.stringify({ error: 'No thoughts recorded in current session' }) : '# Think Session Report\n\n*No thoughts recorded in current session.*'; } if (format === 'json') { return JSON.stringify( { goal: sessionGoal, thoughts, branches: Array.from(branches.entries()), deadEnds, averageConfidence, exportedAt: new Date().toISOString(), }, null, 2 ); } // Markdown format return this.generateMarkdown(data, includeMermaid); }