sequentialthinking

Instructions

Implementation Reference

• index.ts:91-137 (handler)

  The main handler function `processThought` that executes the sequential thinking logic: validates input, stores thought in history, handles branching, formats output, and returns the result (or error).

  public processThought(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } {
    try {
      const validatedInput = this.validateThoughtData(input);
  
      if (validatedInput.thoughtNumber > validatedInput.totalThoughts) {
        validatedInput.totalThoughts = validatedInput.thoughtNumber;
      }
  
      this.thoughtHistory.push(validatedInput);
  
      if (validatedInput.branchFromThought && validatedInput.branchId) {
        if (!this.branches[validatedInput.branchId]) {
          this.branches[validatedInput.branchId] = [];
        }
        this.branches[validatedInput.branchId].push(validatedInput);
      }
  
      if (!this.disableThoughtLogging) {
        const formattedThought = this.formatThought(validatedInput);
        console.error(formattedThought);
      }
  
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            thoughtNumber: validatedInput.thoughtNumber,
            totalThoughts: validatedInput.totalThoughts,
            nextThoughtNeeded: validatedInput.nextThoughtNeeded,
            branches: Object.keys(this.branches),
            thoughtHistoryLength: this.thoughtHistory.length
          }, null, 2)
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            error: error instanceof Error ? error.message : String(error),
            status: 'failed'
          }, null, 2)
        }],
        isError: true
      };
    }
  }

• index.ts:13-23 (schema)

  The `ThoughtData` interface defining the input/output shape for the tool, including thought, thoughtNumber, totalThoughts, isRevision, revisesThought, branchFromThought, branchId, needsMoreThoughts, and nextThoughtNeeded.

  interface ThoughtData {
    thought: string;
    thoughtNumber: number;
    totalThoughts: number;
    isRevision?: boolean;
    revisesThought?: number;
    branchFromThought?: number;
    branchId?: string;
    needsMoreThoughts?: boolean;
    nextThoughtNeeded: boolean;
  }

• index.ts:274-290 (registration)

  Tool registration via `ListToolsRequestSchema` (line 274-276) listing the SEQUENTIAL_THINKING_TOOL, and `CallToolRequestSchema` (line 278-290) dispatching calls with name 'sequentialthinking' to `processThought`.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [SEQUENTIAL_THINKING_TOOL],
  }));
  
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === "sequentialthinking") {
      return thinkingServer.processThought(request.params.arguments);
    }
  
    return {
      content: [{
        type: "text",
        text: `Unknown tool: ${request.params.name}`
      }],
      isError: true
    };
  });

• index.ts:34-61 (helper)

  Helper `validateThoughtData` that validates the input object has required fields (thought, thoughtNumber, totalThoughts, nextThoughtNeeded) with correct types, and returns a clean ThoughtData object.

  private validateThoughtData(input: unknown): ThoughtData {
    const data = input as Record<string, unknown>;
  
    if (!data.thought || typeof data.thought !== 'string') {
      throw new Error('Invalid thought: must be a string');
    }
    if (!data.thoughtNumber || typeof data.thoughtNumber !== 'number') {
      throw new Error('Invalid thoughtNumber: must be a number');
    }
    if (!data.totalThoughts || typeof data.totalThoughts !== 'number') {
      throw new Error('Invalid totalThoughts: must be a number');
    }
    if (typeof data.nextThoughtNeeded !== 'boolean') {
      throw new Error('Invalid nextThoughtNeeded: must be a boolean');
    }
  
    return {
      thought: data.thought,
      thoughtNumber: data.thoughtNumber,
      totalThoughts: data.totalThoughts,
      nextThoughtNeeded: data.nextThoughtNeeded,
      isRevision: data.isRevision as boolean | undefined,
      revisesThought: data.revisesThought as number | undefined,
      branchFromThought: data.branchFromThought as number | undefined,
      branchId: data.branchId as string | undefined,
      needsMoreThoughts: data.needsMoreThoughts as boolean | undefined,
    };
  }

• index.ts:63-89 (helper)

  Helper `formatThought` that creates the visual thought box with border, prefix (Revision/Branch/Thought), and thought number context, using chalk for coloring.

    private formatThought(thoughtData: ThoughtData): string {
      const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;
  
      let prefix = '';
      let context = '';
  
      if (isRevision) {
        prefix = chalk.yellow('🔄 Revision');
        context = ` (revising thought ${revisesThought})`;
      } else if (branchFromThought) {
        prefix = chalk.green('🌿 Branch');
        context = ` (from thought ${branchFromThought}, ID: ${branchId})`;
      } else {
        prefix = chalk.blue('💭 Thought');
        context = '';
      }
  
      const header = `${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
      const border = '─'.repeat(Math.max(header.length, thought.length) + 4);
  
      return `
  ┌${border}┐
  │ ${header} │
  ├${border}┤
  │ ${thought.padEnd(border.length - 2)} │
  └${border}┘`;
    }