Hi-AI

Instructions

Implementation Reference

• src/tools/thinking/thinkAloudProcess.ts:23-83 (handler)

  The main handler function implementing the think_aloud_process tool. Generates a structured think-aloud reasoning process with steps, questions, conclusions, and metacognition based on the provided scenario, perspective, and verbosity.

  export async function thinkAloudProcess(args: { scenario: string; perspective?: string; verbosity?: string }): Promise<ToolResult> {
    const { scenario, perspective = 'analytical', verbosity = 'moderate' } = args;
    
    const thoughtCount = verbosity === 'concise' ? 3 : verbosity === 'moderate' ? 5 : 8;
    const thinkAloudResult = {
      action: 'think_aloud_process',
      scenario,
      perspective,
      verbosity,
      thoughtProcess: Array.from({ length: thoughtCount }, (_, i) => {
        const thoughtNum = i + 1;
        let thoughtStyle = '';
        
        switch (perspective) {
          case 'analytical':
            thoughtStyle = `Analyzing: Let me examine ${scenario} systematically...`;
            break;
          case 'creative':
            thoughtStyle = `Brainstorming: What if I approach ${scenario} differently...`;
            break;
          case 'systematic':
            thoughtStyle = `Step ${thoughtNum}: Following systematic approach to ${scenario}...`;
            break;
          case 'critical':
            thoughtStyle = `Questioning: What assumptions am I making about ${scenario}...`;
            break;
        }
        
        return {
          stepNumber: thoughtNum,
          thought: thoughtStyle,
          reasoning: `In step ${thoughtNum}, I need to consider the implications of ${scenario} from a ${perspective} perspective`,
          questions: [
            `What do I know about this aspect of ${scenario}?`,
            `What don't I know yet?`,
            `What should I explore next?`
          ],
          conclusions: [
            `Based on current analysis...`,
            `This leads me to think that...`,
            `Next I should focus on...`
          ],
          confidence: Math.min(95, 60 + (thoughtNum * 5))
        };
      }),
      metacognition: {
        thinkingStyle: perspective,
        processEffectiveness: verbosity === 'verbose' ? 'highly detailed' : verbosity === 'moderate' ? 'balanced' : 'efficient',
        nextSteps: [
          'Review thinking process for gaps',
          'Validate conclusions against evidence', 
          'Plan concrete actions based on analysis'
        ]
      },
      status: 'success'
    };
    
    return {
      content: [{ type: 'text', text: `Scenario: ${scenario}\nPerspective: ${perspective}\nThoughts: ${thoughtCount}\n${thinkAloudResult.thoughtProcess.map((t, i) => `${i+1}. ${t.thought} (confidence: ${t.confidence}%)`).join('\n')}\n\nNext: ${thinkAloudResult.metacognition.nextSteps.join(', ')}` }]
    };
  }

• src/tools/thinking/thinkAloudProcess.ts:5-21 (schema)

  The ToolDefinition object defining the tool's name, description, input schema (scenario required, optional perspective and verbosity), and annotations.

  export const thinkAloudProcessDefinition: ToolDefinition = {
    name: 'think_aloud_process',
    description: 'think about|consider|what do you think|think about it|let me think|reasoning - Generate think-aloud reasoning process',
    inputSchema: {
      type: 'object',
      properties: {
        scenario: { type: 'string', description: 'Scenario or problem to think through' },
        perspective: { type: 'string', description: 'Thinking perspective', enum: ['analytical', 'creative', 'systematic', 'critical'] },
        verbosity: { type: 'string', description: 'Verbosity level', enum: ['concise', 'moderate', 'verbose'] }
      },
      required: ['scenario']
    },
    annotations: {
      title: 'Think Aloud',
      audience: ['user', 'assistant']
    }
  };

• src/index.ts:624-625 (registration)

  Registration in the executeToolCall switch statement: dispatches calls to the thinkAloudProcess handler.

  case 'think_aloud_process':
    return await thinkAloudProcess(args as any) as CallToolResult;

• src/index.ts:117-117 (registration)

  Inclusion of thinkAloudProcessDefinition in the tools array used for ListTools requests.

  thinkAloudProcessDefinition,

• src/index.ts:84-84 (registration)

  Import statement bringing in the handler and definition from the implementation file.

  import { thinkAloudProcess, thinkAloudProcessDefinition } from './tools/thinking/thinkAloudProcess.js';