@gotza02/seq-thinking 1.1.22 → 1.1.23

package/README.md

@@ -1,35 +1,35 @@
 # MCP Sequential Thinking with Swarm Coordination
 
-[![Version](https://img.shields.io/badge/version-1.1.22-blue.svg)](https://www.npmjs.com/package/@gotza02/seq-thinking)
+[![Version](https://img.shields.io/badge/version-1.1.23-blue.svg)](https://www.npmjs.com/package/@gotza02/seq-thinking)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
 
-**Advanced Sequential Thinking MCP Server** with integrated Swarm Intelligence. This tool empowers your AI environment with structured reasoning, self-correction, and a coordinated team of specialized agents, leveraging your existing local LLM CLI tools.
+**Advanced Sequential Thinking MCP Server** ที่มาพร้อมกับ Swarm Intelligence แบบบูรณาการ เครื่องมือนี้ช่วยเพิ่มประสิทธิภาพให้กับสภาพแวดล้อม AI ของคุณด้วยการให้เหตุผลแบบมีโครงสร้าง การแก้ไขตนเอง และทีมเอเจนต์เฉพาะทางที่ประสานงานกัน โดยใช้ประโยชน์จากเครื่องมือ CLI ของ LLM ในเครื่องที่มีอยู่แล้ว
 
-## 🚀 Key Features
+## 🚀 คุณสมบัติหลัก
 
-*   **🧠 Advanced Sequential Thinking**: Supports branching, merging, and pruning of thought paths.
-*   **🤖 Swarm Intelligence**: Coordinates specialized agents (**Reasoner**, **Critic**, **Synthesizer**, **Meta-Reasoner**, **Specialist**) with Mutex-based concurrency control to prevent race conditions.
-*   **🔌 BYO-LLM (Bring Your Own LLM)**: Connects directly to **Gemini**, **Claude**, **Kimi**, and **OpenCode** via their CLI tools—no extra API keys required if you're already logged in.
-*   **🔄 Auto-Fallback & Robustness**: Automatically switches providers if one fails (e.g., `gemini` -> `claude`). Includes retry logic for resilient task execution.
-*   **💾 Persistence & Recovery**: Automatically saves sessions, agent states, and tasks to disk. Includes a Recovery System that restores interrupted tasks to a pending state on restart.
-*   **🔍 Self-Correction**: Proactively detects logical fallacies and confidence dips, triggering corrective actions.
+*   **🧠 Advanced Sequential Thinking**: รองรับการแตกกิ่ง การรวมกัน และการตัดแต่งเส้นทางการคิด
+*   **🤖 Swarm Intelligence**: ประสานงานเอเจนต์เฉพาะทาง (**Reasoner**, **Critic**, **Synthesizer**, **Meta-Reasoner**, **Specialist**) พร้อมการควบคุมการทำงานพร้อมกันแบบ Mutex เพื่อป้องกันปัญหา race condition
+*   **🔌 BYO-LLM (Bring Your Own LLM)**: เชื่อมต่อโดยตรงกับ **Gemini**, **Claude**, **Kimi**, และ **OpenCode** ผ่าน CLI tools ของพวกเขา—ไม่ต้องใช้ API keys เพิ่มเติมหากคุณล็อกอินอยู่แล้ว
+*   **🔄 Auto-Fallback และความทนทาน**: สลับผู้ให้บริการอัตโนมัติหากผู้ใดผู้หนึ่งล้มเหลว (เช่น `gemini` -> `claude`) รวมถึงลอจิกการ retry สำหรับการดำเนินการงานที่ยืดหยุ่น
+*   **💾 การเก็บข้อมูลและการกู้คืน**: บันทึกเซสชัน สถานะเอเจนต์ และงานไปยังดิสก์อัตโนมัติ รวมถึงระบบกู้คืนที่คืนค่างานที่ถูกขัดจังหวะให้กลับสู่สถานะ pending เมื่อรีสตาร์ท
+*   **🔍 การแก้ไขตนเอง**: ตรวจจับ logical fallacies และการลดลงของความมั่นใจแบบ proactive พร้อมกระตุ้นการดำเนินการแก้ไข
 
-## 📦 Quick Start (NPX)
+## 📦 เริ่มต้นใช้งานอย่างรวดเร็ว (NPX)
 
-You can run this MCP server directly using `npx` without cloning the repository. This is the recommended method.
+คุณสามารถรัน MCP server นี้ได้โดยตรงโดยใช้ `npx` โดยไม่ต้อง clone repository วิธีนี้เป็นวิธีที่แนะนำ
 
-**Prerequisites:** Node.js v18 or higher.
+**ข้อกำหนดเบื้องต้น:** Node.js v18 หรือสูงกว่า
 
 ```bash
 npx -y @gotza02/seq-thinking
 ```
 
-## ⚙️ MCP Configuration
+## ⚙️ การตั้งค่า MCP
 
-To use this tool with MCP clients (like **Claude Desktop**, **Cline**, or **Cursor**), add the following configuration to your settings file.
+หากต้องการใช้เครื่องมือนี้กับ MCP clients (เช่น **Claude Desktop**, **Cline**, หรือ **Cursor**) ให้เพิ่มการตั้งค่าต่อไปนี้ลงในไฟล์ settings ของคุณ
 
-**For Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):
+**สำหรับ Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` บน macOS หรือ `%APPDATA%\Claude\claude_desktop_config.json` บน Windows):
 
 ```json
 {
@@ -48,141 +48,150 @@ To use this tool with MCP clients (like **Claude Desktop**, **Cline**, or **Curs
 }
 ```
 
-### Environment Variables
+### ตัวแปรสภาพแวดล้อม (Environment Variables)
 
-| Variable | Description | Default | Example |
+| ตัวแปร | คำอธิบาย | ค่าเริ่มต้น | ตัวอย่าง |
 |----------|-------------|---------|---------|
-| `provider` | Comma-separated list of LLM CLIs to use. The system tries them in order. | `gemini` | `gemini,claude,kimi` |
-| `MOCK_LLM` | If `true`, returns mock responses (for testing without API costs). | `false` | `true` |
-| `LOG_LEVEL` | Logging verbosity (`DEBUG`, `INFO`, `WARN`, `ERROR`). | `INFO` | `DEBUG` |
-| `MCP_DATA_DIR` | Custom directory for session/agent persistence. | `./data` | `/home/user/mcp-data` |
-| `TMPDIR` | If `MCP_DATA_DIR` is not set, data will be stored in `$TMPDIR/data`. | `./` | `/tmp` |
+| `provider` | รายการ LLM CLIs ที่คั่นด้วยจุลภาค ระบบจะลองใช้ตามลำดับ | `gemini` | `gemini,claude,kimi` |
+| `MOCK_LLM` | หากเป็น `true` จะคืนค่า mock responses (สำหรับการทดสอบโดยไม่มีค่าใช้จ่าย API) | `false` | `true` |
+| `LOG_LEVEL` | ระดับความละเอียดของการบันทึก (`DEBUG`, `INFO`, `WARN`, `ERROR`) | `INFO` | `DEBUG` |
+| `MCP_DATA_DIR` | ไดเรกทอรีที่กำหนดเองสำหรับการเก็บข้อมูลเซสชัน/เอเจนต์ | `./data` | `/home/user/mcp-data` |
+| `TMPDIR` | หากไม่ได้ตั้งค่า `MCP_DATA_DIR` ข้อมูลจะถูกเก็บใน `$TMPDIR/data` | `./` | `/tmp` |
 
-**Supported CLI Tools:**
-*   **Gemini:** Requires `gemini` CLI installed and authenticated.
-*   **Claude:** Requires `claude` (Claude Code) CLI installed and authenticated.
-*   **Kimi:** Requires `kimi` (Kimi Code CLI) installed and authenticated.
-*   **OpenCode:** Requires `opencode` CLI.
+**เครื่องมือ CLI ที่รองรับ:**
+*   **Gemini:** ต้องติดตั้ง `gemini` CLI และยืนยันตัวตนแล้ว
+*   **Claude:** ต้องติดตั้ง `claude` (Claude Code) CLI และยืนยันตัวตนแล้ว
+*   **Kimi:** ต้องติดตั้ง `kimi` (Kimi Code CLI) และยืนยันตัวตนแล้ว
+*   **OpenCode:** ต้องติดตั้ง `opencode` CLI
 
-## 🛠️ Usage
+## 🛠️ การใช้งาน
 
-This server provides two main tools to your AI client:
+เซิร์ฟเวอร์นี้ให้บริการเครื่องมือหลัก 2 อย่างแก่ AI client ของคุณ:
 
 ### 1. `advanced_sequential_thinking`
-The core thinking engine.
-*   **Operations:** `initialize`, `add_thought`, `branch_thought`, `self_correct`, `complete_session`, etc.
-*   **Use Case:** Deep, step-by-step problem solving with ability to backtrack.
+เครื่องยนต์การคิดหลัก
+*   **Operations:** `initialize`, `add_thought`, `branch_thought`, `self_correct`, `complete_session`, ฯลฯ
+*   **กรณีใช้งาน:** การแก้ปัญหาเชิงลึกแบบเป็นขั้นตอนพร้อมความสามารถในการย้อนกลับ
 
 ### 2. `swarm_agent_coordination`
-The workforce manager.
-*   **Operations:** `register_agent`, `assign_task`, `reach_consensus`, `resolve_conflict`.
-*   **Use Case:** Delegating sub-tasks to specialized "virtual experts" (e.g., asking a "Critic" agent to review a plan).
+ผู้จัดการทีมงาน
+*   **Operations:** `register_agent`, `assign_task`, `reach_consensus`, `resolve_conflict`
+*   **กรณีใช้งาน:** มอบหมายงานย่อยให้กับ "ผู้เชี่ยวชาญเสมือน" เฉพาะทาง (เช่น ขอให้เอเจนต์ "Critic" ตรวจสอบแผน)
 
-## 👨‍💻 Development & Local Installation
+## 👨‍💻 การพัฒนาและการติดตั้งในเครื่อง
 
-If you want to modify the code or contribute:
+หากคุณต้องการแก้ไขโค้ดหรือมีส่วนร่วม:
 
 ```bash
-# Clone the repository
+# Clone repository
 git clone https://github.com/yourusername/mcp-sequential-thinking.git
 cd mcp-sequential-thinking
 
-# Install dependencies
+# ติดตั้ง dependencies
 npm install
 
-# Build the project
+# Build โปรเจกต์
 npm run build
 
-# Run tests
+# รันการทดสอบ
 export MOCK_LLM=true
 npm test
 ```
 
-## 🏗️ Architecture
+## 🏗️ สถาปัตยกรรม
 
-The system is built on a modular architecture:
-*   **Orchestration Layer:** Manages state, flow control, and error handling.
-*   **Swarm Coordinator:** Assigns tasks based on agent capabilities and availability.
-*   **Thought Graph:** A directed acyclic graph (DAG) representing the reasoning process.
-*   **LLM Adapter:** A unified interface for communicating with various CLI-based models.
+ระบบถูกสร้างบนสถาปัตยกรรมแบบโมดูลาร์:
+*   **Orchestration Layer:** จัดการสถานะ การควบคุม flow และการจัดการข้อผิดพลาด
+*   **Swarm Coordinator:** มอบหมายงานตามความสามารถและความพร้อมของเอเจนต์
+*   **Thought Graph:** กราฟแบบ directed acyclic graph (DAG) ที่แสดงกระบวนการให้เหตุผล
+*   **LLM Adapter:** อินเทอร์เฟซแบบรวมศูนย์สำหรับสื่อสารกับโมเดลต่างๆ ที่ใช้ CLI
 
-## 📝 Changelog
+## 📝 ประวัติการเปลี่ยนแปลง (Changelog)
+
+### v1.1.23 (2026-02-04)
+- **Security (สำคัญ):** แก้ไขช่องโหว่ Shell Injection โดยใช้ execFile แทน exec
+- **Security (สำคัญ):** แก้ไขช่องโหว่ Path Traversal โดยเพิ่มการตรวจสอบ ID
+- **คุณสมบัติ:** สร้างระบบ Zod Validation สำหรับตรวจสอบ inputs ทั้งหมด
+- **คุณสมบัติ:** รวมค่าคงที่ทั้งหมดไว้ใน constants.ts
+- **แก้ไข:** แก้ไข version mismatch (1.1.21 → 1.1.22)
+- **ปรับปรุง:** เพิ่ม Unit Tests สำหรับ SpecialistAgent จาก 3 เป็น 38 tests
+- **เอกสาร:** เพิ่มเอกสาร API Reference (docs/API.md)
 
 ### v1.1.22 (2026-02-04)
-- **Fix (Critical):** Implemented input sanitization in `handleSequentialThinking` to strip hallucinated XML tags (e.g., `<arg_key>`) from operation strings. This resolves "Unknown operation" errors when the LLM malforms tool arguments.
+- **แก้ไข (สำคัญ):** ใช้งาน input sanitization ใน `handleSequentialThinking` เพื่อลบ XML tags ที่เกิดจาก hallucination (เช่น `<arg_key>`) ออกจากสตริง operation แก้ไขข้อผิดพลาด "Unknown operation" เมื่อ LLM สร้าง arguments ของเครื่องมือผิดรูปแบบ
 
 ### v1.1.21 (2026-02-04)
-- **Fix (Swarm):** Significantly improved technical robustness of Swarm Agent Delegation.
-- **Improvement:** Added comprehensive logging across the task lifecycle (submission, assignment, execution).
-- **Improvement:** Enhanced error handling in `delegate_to_swarm` operation to capture and report execution exceptions.
-- **Fix:** Fixed a bug where failed agent execution wasn't properly triggering the reassignment logic.
+- **แก้ไข (Swarm):** ปรับปรุงความทนทานทางเทคนิคของ Swarm Agent Delegation อย่างมาก
+- **ปรับปรุง:** เพิ่มการบันทึกอย่างครอบคลุมตลอดวงจรชีวิตของงาน (submission, assignment, execution)
+- **ปรับปรุง:** ปรับปรุงการจัดการข้อผิดพลาดใน operation `delegate_to_swarm` เพื่อจับและรายงานข้อยกเว้นการดำเนินการ
+- **แก้ไข:** แก้ไขบั๊กที่การดำเนินการของเอเจนต์ล้มเหลวไม่ได้กระตุ้นลอจิกการมอบหมายใหม่
 
 ### v1.1.20 (2026-02-04)
-- **Fix (Kimi):** Updated `kimi` CLI integration to use the correct non-interactive syntax (`kimi --quiet --prompt`). Fixes issues where `kimi chat` was failing due to incorrect command structure.
+- **แก้ไข (Kimi):** อัปเดตการบูรณาการ `kimi` CLI ให้ใช้ syntax แบบ non-interactive ที่ถูกต้อง (`kimi --quiet --prompt`) แก้ไขปัญหาที่ `kimi chat` ล้มเหลวเนื่องจากโครงสร้างคำสั่งไม่ถูกต้อง
 
 ### v1.1.19 (2026-02-04)
-- **Feature (Persistence):** Implemented Task Journaling and Recovery System. Interrupted tasks (e.g., due to crash/restart) are now automatically restored to a PENDING state.
-- **Feature (Concurrency):** Added Mutex-based locking to Swarm Coordinator to prevent race conditions during task assignment and execution.
-- **Improvement:** Enhanced `TaskQueueManager` with integrated persistence logic.
+- **คุณสมบัติ (Persistence):** ใช้งานระบบ Task Journaling และ Recovery งานที่ถูกขัดจังหวะ (เช่น เนื่องจาก crash/restart) จะถูกกู้คืนให้กลับสู่สถานะ PENDING โดยอัตโนมัติ
+- **คุณสมบัติ (Concurrency):** เพิ่ม Mutex-based locking ให้กับ Swarm Coordinator เพื่อป้องกัน race conditions ระหว่างการมอบหมายและดำเนินการงาน
+- **ปรับปรุง:** ปรับปรุง `TaskQueueManager` ด้วยลอจิกการเก็บข้อมูลแบบบูรณาการ
 
 ### v1.1.18 (2026-02-03)
-- **Fix:** Critical fix for binary distribution. Restored `cli.js` entry point to ensure compatibility with `npx` and global installation.
-- **Improvement:** More robust main module detection for ESM.
+- **แก้ไข:** แก้ไขสำคัญสำหรับการกระจาย binary คืนค่า entry point `cli.js` เพื่อให้เข้ากันได้กับ `npx` และการติดตั้งแบบ global
+- **ปรับปรุง:** ตรวจจับโมดูลหลักที่แข็งแกร่งขึ้นสำหรับ ESM
 
 ### v1.1.17 (2026-02-03)
-- **Improvement:** Optimized data directory logic to default to `./data` in the current directory even if `TMPDIR` is present (common in CLI environments), while still allowing `TMPDIR` and `MCP_DATA_DIR` overrides.
+- **ปรับปรุง:** ปรับปรุงลอจิกไดเรกทอรีข้อมูลให้ค่าเริ่มต้นเป็น `./data` ในไดเรกทอรีปัจจุบัน แม้ว่าจะมี `TMPDIR` (พบบ่อยในสภาพแวดล้อม CLI) ในขณะที่ยังอนุญาตให้ override ด้วย `TMPDIR` และ `MCP_DATA_DIR` ได้
 
 ### v1.1.16 (2026-02-03)
-- **Feature:** Added support for `MCP_DATA_DIR` and `TMPDIR` environment variables for flexible data persistence locations.
+- **คุณสมบัติ:** เพิ่มการรองรับตัวแปรสภาพแวดล้อม `MCP_DATA_DIR` และ `TMPDIR` สำหรับตำแหน่งการเก็บข้อมูลที่ยืดหยุ่น
 
 ### v1.1.15 (2026-02-03)
-- **Feature:** Added support for `LOG_LEVEL` environment variable.
-- **Improvement:** Better constructor initialization for `MCPServer`.
+- **คุณสมบัติ:** เพิ่มการรองรับตัวแปรสภาพแวดล้อม `LOG_LEVEL`
+- **ปรับปรุง:** การเริ่มต้น constructor ที่ดีขึ้นสำหรับ `MCPServer`
 
 ### v1.1.14 (2026-02-03)
-- **Fix:** Improved robustness of `register_agent` operation.
-- **Fix:** Added aliasing for `type` field to `agentType` to support legacy/confused AI client calls.
-- **Fix:** Added support for extracting `capabilities` from a nested `payload` object.
+- **แก้ไข:** ปรับปรุงความทนทานของ operation `register_agent`
+- **แก้ไข:** เพิ่ม aliasing สำหรับฟิลด์ `type` เป็น `agentType` เพื่อรองรับการเรียกจาก AI client รุ่นเก่า/สับสน
+- **แก้ไข:** เพิ่มการรองรับการดึง `capabilities` จากออบเจกต์ `payload` ที่ซ้อนอยู่
 
 ### v1.1.13 (2026-02-03)
-- **Feature:** Added `SpecialistAgent` type to swarm coordination.
-- **Fix:** Added support for `specialist` and `utility` agent types in `register_agent` operation.
-- **Fix:** Enhanced capability normalization allowing `string[]` when registering agents.
+- **คุณสมบัติ:** เพิ่มประเภท `SpecialistAgent` ให้กับ swarm coordination
+- **แก้ไข:** เพิ่มการรองรับประเภทเอเจนต์ `specialist` และ `utility` ใน operation `register_agent`
+- **แก้ไข:** ปรับปรุงการปรับค่า capabilities ให้รองรับ `string[]` เมื่อลงทะเบียนเอเจนต์
 
 ### v1.1.12 (2026-02-03)
-- **Fix:** Corrected module resolution issues in binary entry point.
-- **Cleanup:** Removed redundant root-level CLI files.
-- **Improvement:** Optimized `package.json` for reliable `npx` distribution.
+- **แก้ไข:** แก้ไขปัญหาการแก้ไขโมดูลใน entry point แบบ binary
+- **Cleanup:** ลบไฟล์ CLI ระดับ root ที่ซ้ำซ้อน
+- **ปรับปรุง:** ปรับปรุง `package.json` สำหรับการกระจาย `npx` ที่เชื่อถือได้
 
 ### v1.1.11 (2026-02-03)
-- **Fix:** Final fix for binary distribution issues.
+- **แก้ไข:** แก้ไขสุดท้ายสำหรับปัญหาการกระจาย binary
 
 ### v1.1.10 (2026-02-03)
-- **Fix:** Refactored binary distribution to ensure reliable `npx` execution.
+- **แก้ไข:** ปรับโครงสร้างการกระจาย binary เพื่อให้การดำเนินการ `npx` เชื่อถือได้
 
 ### v1.1.9 (2026-02-03)
-- **Fix:** Added multiple bin aliases to improve `npx` compatibility.
+- **แก้ไข:** เพิ่ม bin aliases หลายอันเพื่อปรับปรุงความเข้ากันได้กับ `npx`
 
 ### v1.1.8 (2026-02-03)
-- **Fix:** Restored standard bin configuration.
+- **แก้ไข:** คืนค่าการตั้งค่า bin มาตรฐาน
 
 ### v1.1.7 (2026-02-03)
-- **Fix:** Corrected bin path in package.json to ensure `npx` execution compatibility.
+- **แก้ไข:** แก้ไข bin path ใน package.json เพื่อให้เข้ากันได้กับการดำเนินการ `npx`
 
 ### v1.1.5 (2026-02-03)
-- **Doc:** Updated README to prioritize `npx` usage for easier installation.
-- **Doc:** Updated MCP configuration examples to use `npx` command.
+- **เอกสาร:** อัปเดต README เพื่อให้ความสำคัญกับการใช้งาน `npx` เพื่อการติดตั้งที่ง่ายขึ้น
+- **เอกสาร:** อัปเดตตัวอย่างการตั้งค่า MCP ให้ใช้คำสั่ง `npx`
 
 ### v1.1.4 (2026-02-03)
-- **Fix:** Fixed a critical bug in `MetaReasoningAgent` that caused crashes when analyzing thoughts with missing confidence data.
-- **Improvement:** Enhanced robustness of `overall` confidence calculation across all agents.
-- **Doc:** Updated README with comprehensive usage and testing instructions.
+- **แก้ไข:** แก้ไขบั๊กสำคัญใน `MetaReasoningAgent` ที่ทำให้เกิดการ crash เมื่อวิเคราะห์ thoughts ที่ขาดข้อมูล confidence
+- **ปรับปรุง:** ปรับปรุงความทนทานของการคำนวณ confidence `overall` ในเอเจนต์ทั้งหมด
+- **เอกสาร:** อัปเดต README ด้วยคำแนะนำการใช้งานและการทดสอบที่ครอบคลุม
 
 ### v1.1.3 (2026-02-03)
-- **Feature:** Multi-Provider Auto-Fallback.
-- **Feature:** Dynamic Provider Selection per task.
-- **Refactor:** Replaced console logs with structured `Logger`.
+- **คุณสมบัติ:** Multi-Provider Auto-Fallback
+- **คุณสมบัติ:** Dynamic Provider Selection ต่องาน
+- **ปรับโครงสร้าง:** แทนที่ console logs ด้วย `Logger` แบบมีโครงสร้าง
 
-## 📄 License
+## 📄 ใบอนุญาต
 
-MIT License - see [LICENSE](LICENSE) file for details.
+MIT License - ดูรายละเอียดในไฟล์ [LICENSE](LICENSE)

package/SYSTEM_INSTRUCTIONS.md

@@ -1,50 +1,50 @@
-# AI System Instructions for MCP Sequential Thinking
+# คำแนะนำระบบ AI สำหรับ MCP Sequential Thinking
 
-This document provides instructions for AI models (like Gemini or Claude) on how to effectively utilize this MCP server to solve complex problems.
+เอกสารนี้ให้คำแนะนำสำหรับโมเดล AI (เช่น Gemini หรือ Claude) เกี่ยวกับวิธีการใช้งาน MCP server นี้อย่างมีประสิทธิภาพเพื่อแก้ไขปัญหาที่ซับซ้อน
 
-## 1. When to Use These Tools
+## 1. เมื่อใดควรใช้เครื่องมือเหล่านี้
 
-You should invoke the `advanced_sequential_thinking` tool when:
-- The user's request is complex, ambiguous, or requires multi-step planning.
-- You need to explore multiple hypotheses or alternative solutions.
-- You need to perform self-correction or verify your own reasoning.
-- The task requires a "System 2" thinking approach (deliberative and analytical).
+คุณควรเรียกใช้เครื่องมือ `advanced_sequential_thinking` เมื่อ:
+- คำขอของผู้ใช้มีความซับซ้อน คลุมเครือ หรือต้องการการวางแผนหลายขั้นตอน
+- คุณต้องสำรวจสมมติฐานหรือทางเลือกอื่นหลายๆ อย่าง
+- คุณต้องดำเนินการแก้ไขตนเองหรือตรวจสอบการให้เหตุผลของตนเอง
+- งานต้องการวิธีการคิดแบบ "System 2" (การพิจารณาอย่างรอบคอบและวิเคราะห์)
 
-## 2. Decision Logic for Tools
+## 2. ตรรกะการตัดสินใจสำหรับเครื่องมือ
 
-| tool | Use Case |
+| เครื่องมือ | กรณีการใช้งาน |
 |------|----------|
-| `advanced_sequential_thinking` | Core reasoning, branching, and meta-reflection. |
-| `swarm_agent_coordination` | Delegating specific sub-tasks to specialized agents (e.g., Fact-checking, Code Critique). |
+| `advanced_sequential_thinking` | การให้เหตุผลหลัก การแบ่งกิ่ง และการทบทวนเชิงเมตา |
+| `swarm_agent_coordination` | มอบหมายงานย่อยเฉพาะทางให้กับเอเจนต์ผู้เชี่ยวชาญ (เช่น การตรวจสอบข้อเท็จจริง การวิจารณ์โค้ด) |
 
-## 3. Recommended Workflow
+## 3. ขั้นตอนการทำงานที่แนะนำ
 
-### Phase A: Initialization
-1.  **Initialize**: Create a session with a clear `topic`.
-2.  **Adjust Granularity**: Check if the topic is complex enough to require high detail.
+### เฟส A: การเริ่มต้น
+1.  **initialize**: สร้างเซสชันด้วย `topic` ที่ชัดเจน
+2.  **adjust_granularity**: ตรวจสอบว่าหัวข้อมีความซับซ้อนเพียงพอที่ต้องการรายละเอียดสูงหรือไม่
 
-### Phase B: Iterative Reasoning
-1.  **Add Thoughts**: Progress step-by-step. Use `thoughtType` (analysis, hypothesis, etc.) correctly.
-2.  **Branching**: If you reach a decision point with multiple viable paths, use `branch_thought` to explore them in parallel.
-3.  **Self-Correction**: Periodically call `self_correct` or `add_meta_thought` to reflect on your progress.
+### เฟส B: การให้เหตุผลแบบทำซ้ำ
+1.  **add_thought**: ดำเนินการทีละขั้นตอน ใช้ `thoughtType` (analysis, hypothesis, ฯลฯ) ให้ถูกต้อง
+2.  **branch_thought**: หากคุณถึงจุดตัดสินใจที่มีหลายเส้นทางที่เป็นไปได้ ให้ใช้ `branch_thought` เพื่อสำรวจพร้อมกัน
+3.  **self_correct**: เรียกใช้ `self_correct` หรือ `add_meta_thought` เป็นระยะเพื่อทบทวนความคืบหน้าของคุณ
 
-### Phase C: Swarm Delegation (Optional)
-1.  **Register Agents**: If you need specialized help, register a `critic` or `reasoner`.
-2.  **Delegate**: Use `delegate_to_swarm` to let another "brain" analyze a specific thought.
-3.  **Consensus**: Use `reach_consensus` if multiple agents have different outputs.
+### เฟส C: การมอบหมายให้ Swarm (เลือกใช้)
+1.  **register_agent**: หากคุณต้องการความช่วยเหลือเฉพาะทาง ให้ลงทะเบียน `critic` หรือ `reasoner`
+2.  **delegate_to_swarm**: ใช้ `delegate_to_swarm` เพื่อให้ "สมอง" อื่นวิเคราะห์ความคิดเฉพาะข้อ
+3.  **reach_consensus**: ใช้ `reach_consensus` หากเอเจนต์หลายตัวมีผลลัพธ์ที่แตกต่างกัน
 
-### Phase D: Conclusion
-1.  **Merge**: Combine successful branches using `merge_branches`.
-2.  **Complete**: Finalize the session and present the consolidated result to the user.
+### เฟส D: การสรุป
+1.  **merge_branches**: รวมกิ่งที่ประสบความสำเร็จโดยใช้ `merge_branches`
+2.  **complete**: สรุปเซสชันและนำเสนอผลลัพธ์ที่รวบรวมให้กับผู้ใช้
 
-## 4. Best Practices for the AI
+## 4. แนวทางปฏิบัติที่ดีที่สุดสำหรับ AI
 
-- **Maintain Context**: Keep track of the `sessionId`. Use it for all related thoughts.
-- **Calibrate Confidence**: Be honest about confidence levels. If confidence drops below 0.5, explicitly use a `self_correction` thought.
-- **Label Everything**: Use `tags` and `thoughtType` diligently. This helps the system (and the user) understand your mental map.
-- **Meta-Reflection**: Don't just think; think about *how* you are thinking. If you get stuck, use `add_meta_thought` to analyze the pattern.
+- **รักษาบริบท**: ติดตาม `sessionId` ใช้งานสำหรับความคิดที่เกี่ยวข้องทั้งหมด
+- **ปรับเทียบความมั่นใจ**: แสดงความซื่อสัตย์เกี่ยวกับระดับความมั่นใจ หากความมั่นใจต่ำกว่า 0.5 ให้ใช้ความคิด `self_correction` อย่างชัดเจน
+- **ติดป้ายทุกอย่าง**: ใช้ `tags` และ `thoughtType` อย่างขยัน สิ่งนี้ช่วยให้ระบบ (และผู้ใช้) เข้าใจแผนที่ความคิดของคุณ
+- **การทบทวนเชิงเมตา**: ไม่เพียงแค่คิด แต่ต้องคิดถึง *วิธี* ที่คุณกำลังคิด หากคุณติดขัด ให้ใช้ `add_meta_thought` เพื่อวิเคราะห์รูปแบบ
 
-## 5. System Prompt Template
+## 5. เทมเพลตคำสั่งระบบ
 
-When using this MCP server, you may internalize this instruction:
-> "I will use the Sequential Thinking MCP to map out my reasoning process. I will treat complex problems as a graph of thoughts, allowing myself to branch, backtrack, and consult specialized swarm agents when needed to ensure the highest quality output."
+เมื่อใช้ MCP server นี้ คุณอาจทำให้คำสั่งนี้เป็นส่วนหนึ่งของตนเอง:
+> "ฉันจะใช้ Sequential Thinking MCP เพื่อสร้างแผนที่กระบวนการให้เหตุผลของฉัน ฉันจะถือปัญหาที่ซับซ้อนเป็นกราฟของความคิด อนุญาตให้ตนเองแบ่งกิ่ง ย้อนกลับ และปรึกษาเอเจนต์ swarm ผู้เชี่ยวชาญเมื่อจำเป็นเพื่อให้ได้ผลลัพธ์ที่มีคุณภาพสูงสุด"

package/dist/__tests__/agents/base-agent.js

@@ -0,0 +1,215 @@
+/**
+ * Base Agent Class
+ * @module agents/base-agent
+ * @version 1.0.0
+ */
+import { AgentType, AgentStatus } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+/**
+ * Abstract base class for all agents
+ */
+export class BaseAgent {
+    /** Agent ID */
+    id;
+    /** Agent configuration */
+    config;
+    /** Current status */
+    status = AgentStatus.IDLE;
+    /** Current task IDs */
+    currentTasks = new Set();
+    /** Performance history */
+    performanceHistory = [];
+    /** Message handlers */
+    messageHandlers = [];
+    /**
+     * Create a new base agent
+     * @param config - Agent configuration
+     */
+    constructor(config) {
+        this.id = config.id || `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        this.config = {
+            id: this.id,
+            name: config.name,
+            type: config.type || AgentType.UTILITY,
+            subtype: config.subtype,
+            capabilities: config.capabilities || [],
+            maxConcurrentTasks: config.maxConcurrentTasks || 3,
+            confidenceThreshold: config.confidenceThreshold || 0.7,
+            metadata: {
+                createdAt: new Date(),
+                version: '1.0.0',
+                config: config.metadata?.config || {}
+            }
+        };
+    }
+    /**
+     * Execute a task
+     * @param task - Task to execute
+     * @returns Task result
+     */
+    async execute(task) {
+        const startTime = Date.now();
+        this.status = AgentStatus.BUSY;
+        this.currentTasks.add(task.id);
+        try {
+            const result = await this.process(task);
+            const processingTime = Date.now() - startTime;
+            this.performanceHistory.push({
+                taskId: task.id,
+                quality: result.confidence,
+                timeMs: processingTime,
+                timestamp: new Date()
+            });
+            this.currentTasks.delete(task.id);
+            this.status = this.currentTasks.size === 0 ? AgentStatus.IDLE : AgentStatus.BUSY;
+            return result;
+        }
+        catch (error) {
+            this.currentTasks.delete(task.id);
+            this.status = this.currentTasks.size === 0 ? AgentStatus.IDLE : AgentStatus.BUSY;
+            return {
+                taskId: task.id,
+                agentId: this.id,
+                success: false,
+                output: null,
+                confidence: 0,
+                processingTimeMs: Date.now() - startTime,
+                metadata: {
+                    tokensUsed: 0,
+                    reasoningSteps: 0,
+                    intermediateResults: [],
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            };
+        }
+    }
+    /**
+     * Register a message handler
+     * @param handler - Message handler function
+     * @returns Unsubscribe function
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+        return () => {
+            const index = this.messageHandlers.indexOf(handler);
+            if (index > -1) {
+                this.messageHandlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Receive a message
+     * @param message - Message to receive
+     */
+    receiveMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                const result = handler(message);
+                if (result instanceof Promise) {
+                    result.catch(error => {
+                        Logger.error(`Error in message handler for agent ${this.id}`, { error });
+                    });
+                }
+            }
+            catch (error) {
+                Logger.error(`Error in message handler for agent ${this.id}`, { error });
+            }
+        }
+    }
+    /**
+     * Get agent status
+     * @returns Current status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Set agent status
+     * @param status - New status
+     */
+    setStatus(status) {
+        this.status = status;
+    }
+    /**
+     * Get current task IDs
+     * @returns Array of task IDs
+     */
+    getCurrentTasks() {
+        return Array.from(this.currentTasks);
+    }
+    /**
+     * Get performance metrics
+     * @returns Performance metrics
+     */
+    getPerformanceMetrics() {
+        if (this.performanceHistory.length === 0) {
+            return {
+                tasksCompleted: 0,
+                averageQuality: 0,
+                averageTimeMs: 0,
+                successRate: 0
+            };
+        }
+        const completed = this.performanceHistory.length;
+        const avgQuality = this.performanceHistory.reduce((sum, p) => sum + p.quality, 0) / completed;
+        const avgTime = this.performanceHistory.reduce((sum, p) => sum + p.timeMs, 0) / completed;
+        const successRate = this.performanceHistory.filter(p => p.quality > 0.5).length / completed;
+        return {
+            tasksCompleted: completed,
+            averageQuality: avgQuality,
+            averageTimeMs: avgTime,
+            successRate
+        };
+    }
+    /**
+     * Check if agent has a capability
+     * @param capabilityName - Capability name
+     * @returns True if agent has capability
+     */
+    hasCapability(capabilityName) {
+        return this.getCapabilities().some(c => c.name === capabilityName);
+    }
+    /**
+     * Get capability confidence
+     * @param capabilityName - Capability name
+     * @returns Confidence level (0-1)
+     */
+    getCapabilityConfidence(capabilityName) {
+        const cap = this.getCapabilities().find(c => c.name === capabilityName);
+        return cap?.confidence || 0;
+    }
+    /**
+     * Check if agent can handle a task
+     * @param task - Task to check
+     * @returns True if agent can handle task
+     */
+    canHandleTask(task) {
+        const requiredCaps = task.requirements.requiredCapabilities;
+        return requiredCaps.every(cap => this.hasCapability(cap));
+    }
+    /**
+     * Create a task result
+     * @param taskId - Task ID
+     * @param output - Output data
+     * @param confidence - Confidence level
+     * @param processingTimeMs - Processing time in ms
+     * @param metadata - Additional metadata
+     * @returns Task result
+     */
+    createTaskResult(taskId, output, confidence, processingTimeMs, metadata = {}) {
+        return {
+            taskId,
+            agentId: this.id,
+            success: confidence > 0.5,
+            output,
+            confidence,
+            processingTimeMs,
+            metadata: {
+                tokensUsed: metadata.tokensUsed || 0,
+                reasoningSteps: metadata.reasoningSteps || 1,
+                intermediateResults: metadata.intermediateResults || [],
+                error: metadata.error
+            }
+        };
+    }
+}