@jieshe/mcp-sequentialthinking-tools 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Scott Spence
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,264 @@
+# mcp-sequentialthinking-tools
+
+An adaptation of the
+[MCP Sequential Thinking Server](https://github.com/modelcontextprotocol/servers/blob/main/src/sequentialthinking/index.ts)
+designed to guide tool usage in problem-solving. This server helps
+break down complex problems into manageable steps and provides
+recommendations for which MCP tools would be most effective at each
+stage.
+
+<a href="https://glama.ai/mcp/servers/zl990kfusy">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/zl990kfusy/badge" />
+</a>
+
+A Model Context Protocol (MCP) server that combines sequential
+thinking with intelligent tool suggestions. For each step in the
+problem-solving process, it provides confidence-scored recommendations
+for which tools to use, along with rationale for why each tool would
+be appropriate.
+
+## Features
+
+- 🤔 Dynamic and reflective problem-solving through sequential
+  thoughts
+- 🔄 Flexible thinking process that adapts and evolves
+- 🌳 Support for branching and revision of thoughts
+- 🛠️ LLM-driven intelligent tool recommendations for each step
+- 📊 Confidence scoring for tool suggestions
+- 🔍 Detailed rationale for tool recommendations
+- 📝 Step tracking with expected outcomes
+- 🔄 Progress monitoring with previous and remaining steps
+- 🎯 Alternative tool suggestions for each step
+- 🧠 Memory management with configurable history limits
+- 🗑️ Manual history cleanup capabilities
+
+## How It Works
+
+This server facilitates sequential thinking with MCP tool coordination. The LLM analyzes available tools and their descriptions to make intelligent recommendations, which are then tracked and organized by this server.
+
+The workflow:
+1. LLM provides available MCP tools to the sequential thinking server
+2. LLM analyzes each thought step and recommends appropriate tools
+3. Server tracks recommendations, maintains context, and manages memory
+4. LLM executes recommended tools and continues the thinking process
+
+Each recommendation includes:
+- A confidence score (0-1) indicating how well the tool matches the need
+- A clear rationale explaining why the tool would be helpful
+- A priority level to suggest tool execution order
+- Suggested input parameters for the tool
+- Alternative tools that could also be used
+
+The server works with any MCP tools available in your environment and automatically manages memory to prevent unbounded growth.
+
+## Example Usage
+
+Here's an example of how the server guides tool usage:
+
+```json
+{
+	"thought": "Initial research step to understand what universal reactivity means in Svelte 5",
+	"current_step": {
+		"step_description": "Gather initial information about Svelte 5's universal reactivity",
+		"expected_outcome": "Clear understanding of universal reactivity concept",
+		"recommended_tools": [
+			{
+				"tool_name": "search_docs",
+				"confidence": 0.9,
+				"rationale": "Search Svelte documentation for official information",
+				"priority": 1
+			},
+			{
+				"tool_name": "tavily_search",
+				"confidence": 0.8,
+				"rationale": "Get additional context from reliable sources",
+				"priority": 2
+			}
+		],
+		"next_step_conditions": [
+			"Verify information accuracy",
+			"Look for implementation details"
+		]
+	},
+	"thought_number": 1,
+	"total_thoughts": 5,
+	"next_thought_needed": true
+}
+```
+
+The server tracks your progress and supports:
+
+- Creating branches to explore different approaches
+- Revising previous thoughts with new information
+- Maintaining context across multiple steps
+- Suggesting next steps based on current findings
+
+## Configuration
+
+This server requires configuration through your MCP client. Here are
+examples for different environments:
+
+### Cline Configuration
+
+Add this to your Cline MCP settings:
+
+```json
+{
+	"mcpServers": {
+		"mcp-sequentialthinking-tools": {
+			"command": "npx",
+			"args": ["-y", "mcp-sequentialthinking-tools"],
+			"env": {
+				"MAX_HISTORY_SIZE": "1000"
+			}
+		}
+	}
+}
+```
+
+### Claude Desktop with WSL Configuration
+
+For WSL environments, add this to your Claude Desktop configuration:
+
+```json
+{
+	"mcpServers": {
+		"mcp-sequentialthinking-tools": {
+			"command": "wsl.exe",
+			"args": [
+				"bash",
+				"-c",
+				"MAX_HISTORY_SIZE=1000 source ~/.nvm/nvm.sh && /home/username/.nvm/versions/node/v20.12.1/bin/npx mcp-sequentialthinking-tools"
+			]
+		}
+	}
+}
+```
+
+## API
+
+The server implements a single MCP tool with configurable parameters:
+
+### sequentialthinking_tools
+
+A tool for dynamic and reflective problem-solving through thoughts,
+with intelligent tool recommendations.
+
+Parameters:
+
+- `available_mcp_tools` (array, required): Array of MCP tool names available for use (e.g., ["mcp-omnisearch", "mcp-turso-cloud"])
+- `thought` (string, required): Your current thinking step
+- `next_thought_needed` (boolean, required): Whether another thought
+  step is needed
+- `thought_number` (integer, required): Current thought number
+- `total_thoughts` (integer, required): Estimated total thoughts
+  needed
+- `is_revision` (boolean, optional): Whether this revises previous
+  thinking
+- `revises_thought` (integer, optional): Which thought is being
+  reconsidered
+- `branch_from_thought` (integer, optional): Branching point thought
+  number
+- `branch_id` (string, optional): Branch identifier
+- `needs_more_thoughts` (boolean, optional): If more thoughts are
+  needed
+- `current_step` (object, optional): Current step recommendation with:
+  - `step_description`: What needs to be done
+  - `recommended_tools`: Array of tool recommendations with confidence
+    scores
+  - `expected_outcome`: What to expect from this step
+  - `next_step_conditions`: Conditions for next step
+- `previous_steps` (array, optional): Steps already recommended
+- `remaining_steps` (array, optional): High-level descriptions of
+  upcoming steps
+
+## Memory Management
+
+The server includes built-in memory management to prevent unbounded growth:
+
+- **History Limit**: Configurable maximum number of thoughts to retain (default: 1000)
+- **Automatic Trimming**: History automatically trims when limit is exceeded
+- **Manual Cleanup**: Server provides methods to clear history when needed
+
+### Configuring History Size
+
+You can configure the history size by setting the `MAX_HISTORY_SIZE` environment variable:
+
+```json
+{
+  "mcpServers": {
+    "mcp-sequentialthinking-tools": {
+      "command": "npx",
+      "args": ["-y", "mcp-sequentialthinking-tools"],
+      "env": {
+        "MAX_HISTORY_SIZE": "500"
+      }
+    }
+  }
+}
+```
+
+Or for local development:
+```bash
+MAX_HISTORY_SIZE=2000 npx mcp-sequentialthinking-tools
+```
+
+## Development
+
+### Setup
+
+1. Clone the repository
+2. Install dependencies:
+
+```bash
+pnpm install
+```
+
+3. Build the project:
+
+```bash
+pnpm build
+```
+
+4. Run in development mode:
+
+```bash
+pnpm dev
+```
+
+### Publishing
+
+The project uses changesets for version management. To publish:
+
+1. Create a changeset:
+
+```bash
+pnpm changeset
+```
+
+2. Version the package:
+
+```bash
+pnpm changeset version
+```
+
+3. Publish to npm:
+
+```bash
+pnpm release
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Built on the
+  [Model Context Protocol](https://github.com/modelcontextprotocol)
+- Adapted from the
+  [MCP Sequential Thinking Server](https://github.com/modelcontextprotocol/servers/blob/main/src/sequentialthinking/index.ts)

package/dist/formatter.d.ts

@@ -0,0 +1,11 @@
+import type { ThoughtData, StepRecommendation } from './types.js';
+/**
+ * Formats a step recommendation into a human-readable string.
+ */
+export declare function formatRecommendation(step: StepRecommendation): string;
+/**
+ * Formats a thought for terminal display with box-drawing characters.
+ * Properly handles ANSI escape codes and multi-line content for accurate border widths.
+ */
+export declare function formatThought(thoughtData: ThoughtData): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGlE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAkBrE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAsD9D"}

package/dist/formatter.js

@@ -0,0 +1,71 @@
+/**
+ * Output formatting for sequential thinking thoughts.
+ * Handles ANSI-safe border calculation and multi-line content.
+ */
+import chalk from 'chalk';
+import { visualLength, maxLineWidth } from './utils.js';
+/**
+ * Formats a step recommendation into a human-readable string.
+ */
+export function formatRecommendation(step) {
+    const tools = step.recommended_tools
+        .map((tool) => {
+        const alternatives = tool.alternatives?.length
+            ? ` (alternatives: ${tool.alternatives.join(', ')})`
+            : '';
+        const inputs = tool.suggested_inputs
+            ? `\n    Suggested inputs: ${JSON.stringify(tool.suggested_inputs)}`
+            : '';
+        return `  - ${tool.tool_name} (priority: ${tool.priority})${alternatives}\n    Rationale: ${tool.rationale}${inputs}`;
+    })
+        .join('\n');
+    const conditions = step.next_step_conditions
+        ? `\nConditions for next step:\n  - ${step.next_step_conditions.join('\n  - ')}`
+        : '';
+    return `Step: ${step.step_description}\nRecommended Tools:\n${tools}\nExpected Outcome: ${step.expected_outcome}${conditions}`;
+}
+/**
+ * Formats a thought for terminal display with box-drawing characters.
+ * Properly handles ANSI escape codes and multi-line content for accurate border widths.
+ */
+export function formatThought(thoughtData) {
+    const { thought_number, total_thoughts, thought, is_revision, revises_thought, branch_from_thought, branch_id, current_step, } = thoughtData;
+    let prefix = '';
+    let context = '';
+    if (is_revision) {
+        prefix = chalk.yellow('🔄 Revision');
+        context = ` (revising thought ${revises_thought})`;
+    }
+    else if (branch_from_thought) {
+        prefix = chalk.green('🌿 Branch');
+        context = ` (from thought ${branch_from_thought}, ID: ${branch_id})`;
+    }
+    else {
+        prefix = chalk.blue('💭 Thought');
+        context = '';
+    }
+    const header = `${prefix} ${thought_number}/${total_thoughts}${context}`;
+    let content = thought;
+    if (current_step) {
+        content = `${thought}\n\nRecommendation:\n${formatRecommendation(current_step)}`;
+    }
+    // Use ANSI-stripped widths for accurate border calculation
+    const headerWidth = visualLength(header);
+    const contentWidth = maxLineWidth(content);
+    const borderLen = Math.max(headerWidth, contentWidth) + 4;
+    const border = '─'.repeat(borderLen);
+    // Pad each content line individually for proper box alignment
+    const contentLines = content.split('\n').map((line) => {
+        const padding = borderLen - 2 - visualLength(line);
+        return `│ ${line}${' '.repeat(Math.max(0, padding))} │`;
+    });
+    const headerPadding = borderLen - 2 - visualLength(header);
+    return [
+        `┌${border}┐`,
+        `│ ${header}${' '.repeat(Math.max(0, headerPadding))} │`,
+        `├${border}┤`,
+        ...contentLines,
+        `└${border}┘`,
+    ].join('\n');
+}
+//# sourceMappingURL=formatter.js.map

package/dist/formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.js","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * MCP Sequential Thinking Server — Entry Point
+ *
+ * A slim bootstrap that wires up the server, registers the tool,
+ * and starts listening on stdio transport.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG"}

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * MCP Sequential Thinking Server — Entry Point
+ *
+ * A slim bootstrap that wires up the server, registers the tool,
+ * and starts listening on stdio transport.
+ */
+import { McpServer } from 'tmcp';
+import { ValibotJsonSchemaAdapter } from '@tmcp/adapter-valibot';
+import { StdioTransport } from '@tmcp/transport-stdio';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SequentialThinkingSchema, SEQUENTIAL_THINKING_TOOL } from './schema.js';
+import { ToolAwareSequentialThinkingServer } from './server.js';
+// ---------------------------------------------------------------------------
+// Package metadata
+// ---------------------------------------------------------------------------
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const { name, version } = packageJson;
+// ---------------------------------------------------------------------------
+// MCP server setup
+// ---------------------------------------------------------------------------
+const adapter = new ValibotJsonSchemaAdapter();
+const server = new McpServer({
+    name,
+    version,
+    description: 'MCP server for Sequential Thinking Tools',
+}, {
+    adapter,
+    capabilities: {
+        tools: { listChanged: true },
+    },
+});
+// ---------------------------------------------------------------------------
+// Core thinking server
+// ---------------------------------------------------------------------------
+const maxHistorySize = parseInt(process.env.MAX_HISTORY_SIZE || '1000');
+const thinkingServer = new ToolAwareSequentialThinkingServer({
+    available_tools: [],
+    maxHistorySize,
+});
+// ---------------------------------------------------------------------------
+// Register the sequential thinking tool
+// ---------------------------------------------------------------------------
+server.tool({
+    name: 'sequentialthinking_tools',
+    description: SEQUENTIAL_THINKING_TOOL.description,
+    schema: SequentialThinkingSchema,
+}, async (input) => {
+    return thinkingServer.processThought(input);
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioTransport(server);
+    transport.listen();
+    console.error(`Sequential Thinking MCP Server v${version} running on stdio`);
+}
+main().catch((error) => {
+    console.error('Fatal error running server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAEhE,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAC9E,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACtC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAC7B,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,EAAE,OAAO,CAAC,CACzD,CAAC;AACF,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC;AAEtC,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAC9E,MAAM,OAAO,GAAG,IAAI,wBAAwB,EAAE,CAAC;AAC/C,MAAM,MAAM,GAAG,IAAI,SAAS,CAC3B;IACC,IAAI;IACJ,OAAO;IACP,WAAW,EAAE,0CAA0C;CACvD,EACD;IACC,OAAO;IACP,YAAY,EAAE;QACb,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;KAC5B;CACD,CACD,CAAC;AAEF,8EAA8E;AAC9E,uBAAuB;AACvB,8EAA8E;AAC9E,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,MAAM,CAAC,CAAC;AAExE,MAAM,cAAc,GAAG,IAAI,iCAAiC,CAAC;IAC5D,eAAe,EAAE,EAAE;IACnB,cAAc;CACd,CAAC,CAAC;AAEH,8EAA8E;AAC9E,wCAAwC;AACxC,8EAA8E;AAC9E,MAAM,CAAC,IAAI,CACV;IACC,IAAI,EAAE,0BAA0B;IAChC,WAAW,EAAE,wBAAwB,CAAC,WAAW;IACjD,MAAM,EAAE,wBAAwB;CAChC,EACD,KAAK,EAAE,KAAK,EAAE,EAAE;IACf,OAAO,cAAc,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC,CACD,CAAC;AAEF,8EAA8E;AAC9E,QAAQ;AACR,8EAA8E;AAC9E,KAAK,UAAU,IAAI;IAClB,MAAM,SAAS,GAAG,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC;IAC7C,SAAS,CAAC,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,KAAK,CAAC,mCAAmC,OAAO,mBAAmB,CAAC,CAAC;AAC9E,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACtB,OAAO,CAAC,KAAK,CAAC,6BAA6B,EAAE,KAAK,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC"}

package/dist/schema.d.ts

@@ -0,0 +1,127 @@
+import * as v from 'valibot';
+import type { Tool } from './types.js';
+export declare const ToolRecommendationSchema: v.ObjectSchema<{
+    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+    readonly priority: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence">]>;
+    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+        [x: string]: unknown;
+    }, "Optional suggested parameters">]>, undefined>;
+    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+}, undefined>;
+export declare const StepRecommendationSchema: v.ObjectSchema<{
+    readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+    readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+        readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+        readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+        readonly priority: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence">]>;
+        readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+            [x: string]: unknown;
+        }, "Optional suggested parameters">]>, undefined>;
+        readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        tool_name: string;
+        confidence: number;
+        rationale: string;
+        priority: number;
+        suggested_inputs?: {
+            [x: string]: unknown;
+        } | undefined;
+        alternatives?: string[] | undefined;
+    }[], "Tools recommended for this step">]>;
+    readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+    readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+}, undefined>;
+export declare const SequentialThinkingSchema: v.ObjectSchema<{
+    readonly available_mcp_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of MCP tool names available for use (e.g., [\"mcp-omnisearch\", \"mcp-turso-cloud\"])">]>;
+    readonly thought: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Your current thinking step">]>;
+    readonly next_thought_needed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether another thought step is needed">]>;
+    readonly thought_number: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Current thought number">]>;
+    readonly total_thoughts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Estimated total thoughts needed">]>;
+    readonly is_revision: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this revises previous thinking">]>, undefined>;
+    readonly revises_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Which thought is being reconsidered">]>, undefined>;
+    readonly branch_from_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Branching point thought number">]>, undefined>;
+    readonly branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Branch identifier">]>, undefined>;
+    readonly needs_more_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "If more thoughts are needed">]>, undefined>;
+    readonly current_step: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+        readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+            readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+            readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+            readonly priority: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence">]>;
+            readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Optional suggested parameters">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority: number;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[], "Tools recommended for this step">]>;
+        readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+        readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+    }, undefined>, v.DescriptionAction<{
+        step_description: string;
+        recommended_tools: {
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority: number;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[];
+        expected_outcome: string;
+        next_step_conditions?: string[] | undefined;
+    }, "Current step recommendation">]>, undefined>;
+    readonly previous_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+        readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+            readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+            readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+            readonly priority: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence">]>;
+            readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Optional suggested parameters">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority: number;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[], "Tools recommended for this step">]>;
+        readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+        readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        step_description: string;
+        recommended_tools: {
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority: number;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[];
+        expected_outcome: string;
+        next_step_conditions?: string[] | undefined;
+    }[], "Steps already recommended">]>, undefined>;
+    readonly remaining_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "High-level descriptions of upcoming steps">]>, undefined>;
+}, undefined>;
+export declare const SEQUENTIAL_THINKING_TOOL: Tool;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AA2EvC,eAAO,MAAM,wBAAwB;;;;;;;;;aA2BnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;aAiBnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyDnC,CAAC;AAEH,eAAO,MAAM,wBAAwB,EAAE,IAItC,CAAC"}

package/dist/schema.js

@@ -0,0 +1,108 @@
+import * as v from 'valibot';
+const TOOL_DESCRIPTION = `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
+
+IMPORTANT: This server facilitates sequential thinking with MCP tool coordination. The LLM analyzes available tools and their descriptions to make intelligent recommendations, which are then tracked and organized by this server.
+
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+- When you need guidance on which tools to use and in what order
+
+Key features:
+- You can adjust total_thoughts up or down as you progress
+- You can question or revise previous thoughts
+- You can add more thoughts even after reaching what seemed like the end
+- You can express uncertainty and explore alternative approaches
+- Not every thought needs to build linearly - you can branch or backtrack
+- Generates a solution hypothesis
+- Verifies the hypothesis based on the Chain of Thought steps
+- Recommends appropriate tools for each step
+- Provides rationale for tool recommendations
+- Suggests tool execution order and parameters
+- Tracks previous recommendations and remaining steps
+
+Parameters explained:
+- available_mcp_tools: Array of MCP tool names that are available for use (e.g., ["mcp-omnisearch", "mcp-turso-cloud"])
+- thought: Your current thinking step, which can include:
+* Regular analytical steps
+* Revisions of previous thoughts
+* Questions about previous decisions
+* Realizations about needing more analysis
+* Changes in approach
+* Hypothesis generation
+* Hypothesis verification
+* Tool recommendations and rationale
+- next_thought_needed: True if you need more thinking, even if at what seemed like the end
+- thought_number: Current number in sequence (can go beyond initial total if needed)
+- total_thoughts: Current estimate of thoughts needed (can be adjusted up/down)
+- is_revision: A boolean indicating if this thought revises previous thinking
+- revises_thought: If is_revision is true, which thought number is being reconsidered
+- branch_from_thought: If branching, which thought number is the branching point
+- branch_id: Identifier for the current branch (if any)
+- needs_more_thoughts: If reaching end but realizing more thoughts needed
+- current_step: Current step recommendation, including:
+* step_description: What needs to be done
+* recommended_tools: Tools recommended for this step
+* expected_outcome: What to expect from this step
+* next_step_conditions: Conditions to consider for the next step
+- previous_steps: Steps already recommended
+- remaining_steps: High-level descriptions of upcoming steps
+
+You should:
+1. Start with an initial estimate of needed thoughts, but be ready to adjust
+2. Feel free to question or revise previous thoughts
+3. Don't hesitate to add more thoughts if needed, even at the "end"
+4. Express uncertainty when present
+5. Mark thoughts that revise previous thinking or branch into new paths
+6. Ignore information that is irrelevant to the current step
+7. Generate a solution hypothesis when appropriate
+8. Verify the hypothesis based on the Chain of Thought steps
+9. Consider available tools that could help with the current step
+10. Provide clear rationale for tool recommendations
+11. Suggest specific tool parameters when appropriate
+12. Consider alternative tools for each step
+13. Track progress through the recommended steps
+14. Provide a single, ideally correct answer as the final output
+15. Only set next_thought_needed to false when truly done and a satisfactory answer is reached`;
+export const ToolRecommendationSchema = v.object({
+    tool_name: v.pipe(v.string(), v.description('Name of the tool being recommended')),
+    confidence: v.pipe(v.number(), v.minValue(0), v.maxValue(1), v.description('0-1 indicating confidence in recommendation')),
+    rationale: v.pipe(v.string(), v.description('Why this tool is recommended')),
+    priority: v.pipe(v.number(), v.description('Order in the recommendation sequence')),
+    suggested_inputs: v.optional(v.pipe(v.record(v.string(), v.unknown()), v.description('Optional suggested parameters'))),
+    alternatives: v.optional(v.pipe(v.array(v.string()), v.description('Alternative tools that could be used')))
+});
+export const StepRecommendationSchema = v.object({
+    step_description: v.pipe(v.string(), v.description('What needs to be done')),
+    recommended_tools: v.pipe(v.array(ToolRecommendationSchema), v.description('Tools recommended for this step')),
+    expected_outcome: v.pipe(v.string(), v.description('What to expect from this step')),
+    next_step_conditions: v.optional(v.pipe(v.array(v.string()), v.description('Conditions to consider for the next step')))
+});
+export const SequentialThinkingSchema = v.object({
+    available_mcp_tools: v.pipe(v.array(v.string()), v.description('Array of MCP tool names available for use (e.g., ["mcp-omnisearch", "mcp-turso-cloud"])')),
+    thought: v.pipe(v.string(), v.description('Your current thinking step')),
+    next_thought_needed: v.pipe(v.boolean(), v.description('Whether another thought step is needed')),
+    thought_number: v.pipe(v.number(), v.minValue(1), v.description('Current thought number')),
+    total_thoughts: v.pipe(v.number(), v.minValue(1), v.description('Estimated total thoughts needed')),
+    is_revision: v.optional(v.pipe(v.boolean(), v.description('Whether this revises previous thinking'))),
+    revises_thought: v.optional(v.pipe(v.number(), v.minValue(1), v.description('Which thought is being reconsidered'))),
+    branch_from_thought: v.optional(v.pipe(v.number(), v.minValue(1), v.description('Branching point thought number'))),
+    branch_id: v.optional(v.pipe(v.string(), v.description('Branch identifier'))),
+    needs_more_thoughts: v.optional(v.pipe(v.boolean(), v.description('If more thoughts are needed'))),
+    current_step: v.optional(v.pipe(StepRecommendationSchema, v.description('Current step recommendation'))),
+    previous_steps: v.optional(v.pipe(v.array(StepRecommendationSchema), v.description('Steps already recommended'))),
+    remaining_steps: v.optional(v.pipe(v.array(v.string()), v.description('High-level descriptions of upcoming steps')))
+});
+export const SEQUENTIAL_THINKING_TOOL = {
+    name: 'sequentialthinking_tools',
+    description: TOOL_DESCRIPTION,
+    inputSchema: {} // This will be handled by tmcp with the schema above
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Core Sequential Thinking Server with tool-aware capabilities.
+ *
+ * Responsibilities:
+ * - Process and store thought chains with branching/revision support
+ * - Track tool recommendations per step
+ * - Manage memory with configurable history limits
+ */
+import type * as v from 'valibot';
+import type { SequentialThinkingSchema } from './schema.js';
+import type { Tool, ServerOptions } from './types.js';
+export declare class ToolAwareSequentialThinkingServer {
+    private thoughtHistory;
+    private branches;
+    private availableTools;
+    private readonly maxHistorySize;
+    constructor(options?: ServerOptions);
+    /** Returns a snapshot of all registered tools. */
+    getAvailableTools(): Tool[];
+    /** Returns the current thought history length. */
+    getHistoryLength(): number;
+    /** Returns the current branch IDs. */
+    getBranchIds(): string[];
+    /** Clears all thought history and branches. */
+    clearHistory(): void;
+    /** Registers a new tool. Rejects duplicates. */
+    addTool(tool: Tool): void;
+    /**
+     * Processes a single thought step.
+     *
+     * Key behaviors:
+     * - Auto-adjusts total_thoughts if thought_number exceeds it
+     * - Deep-clones input before mutation to prevent side effects
+     * - Trims history when maxHistorySize is exceeded
+     * - Tracks branch membership for branched thoughts
+     */
+    processThought(input: v.InferInput<typeof SequentialThinkingSchema>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAC;AAClC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAe,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKnE,qBAAa,iCAAiC;IAC7C,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAqC;IACrD,OAAO,CAAC,cAAc,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,OAAO,GAAE,aAAkB;IAyBvC,kDAAkD;IAC3C,iBAAiB,IAAI,IAAI,EAAE;IAIlC,kDAAkD;IAC3C,gBAAgB,IAAI,MAAM;IAIjC,sCAAsC;IAC/B,YAAY,IAAI,MAAM,EAAE;IAI/B,+CAA+C;IACxC,YAAY,IAAI,IAAI;IAM3B,gDAAgD;IACzC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAShC;;;;;;;;OAQG;IACU,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC;;;;;;;;;;;;;CAmFhF"}

package/dist/server.js

@@ -0,0 +1,130 @@
+import { SEQUENTIAL_THINKING_TOOL } from './schema.js';
+import { formatThought } from './formatter.js';
+import { deepClone } from './utils.js';
+export class ToolAwareSequentialThinkingServer {
+    thoughtHistory = [];
+    branches = {};
+    availableTools = new Map();
+    maxHistorySize;
+    constructor(options = {}) {
+        this.maxHistorySize = options.maxHistorySize || 1000;
+        // Always include the sequential thinking tool itself
+        const tools = [
+            SEQUENTIAL_THINKING_TOOL,
+            ...(options.available_tools || []),
+        ];
+        for (const tool of tools) {
+            if (this.availableTools.has(tool.name)) {
+                console.error(`Warning: Duplicate tool name '${tool.name}' - using first occurrence`);
+                continue;
+            }
+            this.availableTools.set(tool.name, tool);
+        }
+        console.error('Available tools:', Array.from(this.availableTools.keys()));
+    }
+    /** Returns a snapshot of all registered tools. */
+    getAvailableTools() {
+        return Array.from(this.availableTools.values());
+    }
+    /** Returns the current thought history length. */
+    getHistoryLength() {
+        return this.thoughtHistory.length;
+    }
+    /** Returns the current branch IDs. */
+    getBranchIds() {
+        return Object.keys(this.branches);
+    }
+    /** Clears all thought history and branches. */
+    clearHistory() {
+        this.thoughtHistory = [];
+        this.branches = {};
+        console.error('History cleared');
+    }
+    /** Registers a new tool. Rejects duplicates. */
+    addTool(tool) {
+        if (this.availableTools.has(tool.name)) {
+            console.error(`Warning: Tool '${tool.name}' already exists`);
+            return;
+        }
+        this.availableTools.set(tool.name, tool);
+        console.error(`Added tool: ${tool.name}`);
+    }
+    /**
+     * Processes a single thought step.
+     *
+     * Key behaviors:
+     * - Auto-adjusts total_thoughts if thought_number exceeds it
+     * - Deep-clones input before mutation to prevent side effects
+     * - Trims history when maxHistorySize is exceeded
+     * - Tracks branch membership for branched thoughts
+     */
+    async processThought(input) {
+        try {
+            // Deep clone to prevent mutation of the caller's input object
+            const thoughtData = deepClone(input);
+            // Auto-adjust total if thought_number exceeds estimate
+            if (thoughtData.thought_number > thoughtData.total_thoughts) {
+                thoughtData.total_thoughts = thoughtData.thought_number;
+            }
+            // Accumulate current step into previous_steps history
+            if (thoughtData.current_step) {
+                if (!thoughtData.previous_steps) {
+                    thoughtData.previous_steps = [];
+                }
+                thoughtData.previous_steps.push(deepClone(thoughtData.current_step));
+            }
+            // Store in history
+            this.thoughtHistory.push(thoughtData);
+            // Prevent memory leaks by trimming oldest entries
+            if (this.thoughtHistory.length > this.maxHistorySize) {
+                this.thoughtHistory = this.thoughtHistory.slice(-this.maxHistorySize);
+                console.error(`History trimmed to ${this.maxHistorySize} items`);
+            }
+            // Track branch membership
+            if (thoughtData.branch_from_thought && thoughtData.branch_id) {
+                if (!this.branches[thoughtData.branch_id]) {
+                    this.branches[thoughtData.branch_id] = [];
+                }
+                this.branches[thoughtData.branch_id].push(thoughtData);
+            }
+            // Format and log to stderr for debugging
+            const formattedThought = formatThought(thoughtData);
+            console.error(formattedThought);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            thought_number: thoughtData.thought_number,
+                            total_thoughts: thoughtData.total_thoughts,
+                            next_thought_needed: thoughtData.next_thought_needed,
+                            branches: Object.keys(this.branches),
+                            thought_history_length: this.thoughtHistory.length,
+                            available_mcp_tools: thoughtData.available_mcp_tools,
+                            current_step: thoughtData.current_step,
+                            previous_steps: thoughtData.previous_steps,
+                            remaining_steps: thoughtData.remaining_steps,
+                        }, 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,
+            };
+        }
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Type definitions derived from Valibot schemas (Single Source of Truth).
+ * Manual interface definitions are eliminated to avoid duplication.
+ */
+import type * as v from 'valibot';
+import type { ToolRecommendationSchema, StepRecommendationSchema, SequentialThinkingSchema } from './schema.js';
+/** A tool recommendation with confidence scoring */
+export type ToolRecommendation = v.InferOutput<typeof ToolRecommendationSchema>;
+/** A step recommendation with tool suggestions */
+export type StepRecommendation = v.InferOutput<typeof StepRecommendationSchema>;
+/** The full thought data structure */
+export type ThoughtData = v.InferOutput<typeof SequentialThinkingSchema>;
+/** MCP tool definition */
+export interface Tool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Options for constructing the SequentialThinking server */
+export interface ServerOptions {
+    available_tools?: Tool[];
+    maxHistorySize?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAC;AAClC,OAAO,KAAK,EACX,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,aAAa,CAAC;AAErB,oDAAoD;AACpD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,kDAAkD;AAClD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,sCAAsC;AACtC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEzE,0BAA0B;AAC1B,MAAM,WAAW,IAAI;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,6DAA6D;AAC7D,MAAM,WAAW,aAAa;IAC7B,eAAe,CAAC,EAAE,IAAI,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Utility functions for the Sequential Thinking server.
+ */
+/**
+ * Deep clones a value using structured clone.
+ * Used to prevent mutation side effects when modifying input data.
+ */
+export declare function deepClone<T>(value: T): T;
+/**
+ * Strips ANSI escape codes from a string.
+ * Used to get accurate character widths for terminal border formatting.
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Gets the visual display width of a string, ignoring ANSI codes.
+ */
+export declare function visualLength(str: string): number;
+/**
+ * Returns the maximum visual line width from a potentially multi-line string.
+ */
+export declare function maxLineWidth(str: string): number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAExC;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGhD"}

package/dist/utils.js

@@ -0,0 +1,33 @@
+/**
+ * Utility functions for the Sequential Thinking server.
+ */
+/**
+ * Deep clones a value using structured clone.
+ * Used to prevent mutation side effects when modifying input data.
+ */
+export function deepClone(value) {
+    return structuredClone(value);
+}
+/**
+ * Strips ANSI escape codes from a string.
+ * Used to get accurate character widths for terminal border formatting.
+ */
+export function stripAnsi(str) {
+    // Matches all ANSI escape sequences (colors, cursor, etc.)
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\u001B\[[0-9;]*[a-zA-Z]/g, '');
+}
+/**
+ * Gets the visual display width of a string, ignoring ANSI codes.
+ */
+export function visualLength(str) {
+    return stripAnsi(str).length;
+}
+/**
+ * Returns the maximum visual line width from a potentially multi-line string.
+ */
+export function maxLineWidth(str) {
+    const lines = str.split('\n');
+    return Math.max(...lines.map(visualLength));
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAI,KAAQ;IACpC,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,GAAW;IACpC,2DAA2D;IAC3D,4CAA4C;IAC5C,OAAO,GAAG,CAAC,OAAO,CAAC,0BAA0B,EAAE,EAAE,CAAC,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACvC,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACvC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;AAC7C,CAAC"}

package/package.json

@@ -0,0 +1,73 @@
+{
+	"name": "@jieshe/mcp-sequentialthinking-tools",
+	"version": "1.0.0",
+	"description": "MCP server for Sequential Thinking Tools",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"bin": {
+		"mcp-sequentialthinking-tools": "./dist/index.js"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js",
+		"dev": "npx @modelcontextprotocol/inspector dist/index.js",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"changeset": "changeset",
+		"version": "changeset version",
+		"release": "pnpm run build && changeset publish"
+	},
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"sequential-thinking",
+		"problem-solving",
+		"tool-recommendation",
+		"decision-making",
+		"thought-process",
+		"step-by-step",
+		"llm",
+		"ai",
+		"branching-thoughts",
+		"thought-revision",
+		"tool-analysis",
+		"problem-breakdown",
+		"solution-planning",
+		"adaptive-thinking",
+		"reflective-analysis",
+		"tool-confidence"
+	],
+	"author": "Scott Spence",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/JIEeshe/mcp-sequentialthinking-tools.git"
+	},
+	"bugs": {
+		"url": "https://github.com/spences10/mcp-sequentialthinking-tools/issues"
+	},
+	"homepage": "https://github.com/spences10/mcp-sequentialthinking-tools#readme",
+	"dependencies": {
+		"@tmcp/adapter-valibot": "^0.1.5",
+		"@tmcp/transport-stdio": "^0.4.2",
+		"chalk": "^5.6.2",
+		"tmcp": "^1.19.3",
+		"valibot": "^1.3.1"
+	},
+	"devDependencies": {
+		"@changesets/cli": "^2.30.0",
+		"@types/node": "^25.5.0",
+		"typescript": "^6.0.2",
+		"vitest": "^4.1.1"
+	}
+}