npm - @j0hanz/thinkseq-mcp - Versions diffs - 2.1.0 → 2.2.0 - Mend

@j0hanz/thinkseq-mcp 2.1.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/README.md +300 -130
package/dist/app.js +11 -8
package/dist/appConfig/runDependencies.js +26 -20
package/dist/appConfig/shutdown.js +8 -5
package/dist/engine/thoughtStore.d.ts +1 -1
package/dist/engine.js +11 -13
package/dist/instructions.md +36 -23
package/dist/lib/context.js +11 -3
package/dist/lib/diagnostics.d.ts +4 -1
package/dist/lib/diagnostics.js +1 -1
package/dist/lib/errors.d.ts +1 -4
package/dist/lib/errors.js +6 -5
package/dist/lib/mcpLogging.js +25 -9
package/dist/lib/stdioGuards.js +72 -24
package/dist/lib/types.d.ts +1 -1
package/dist/tools/thinkseq.js +12 -15
package/package.json +9 -6

package/README.md CHANGED Viewed

@@ -1,177 +1,217 @@
 # ThinkSeq MCP Server
-<img src="assets/logo.svg" alt="ThinkSeq MCP Server Logo" width="225" />
+[![npm version](https://img.shields.io/npm/v/@j0hanz/thinkseq-mcp)](https://www.npmjs.com/package/@j0hanz/thinkseq-mcp) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D24-green)](https://nodejs.org) [![TypeScript](https://img.shields.io/badge/TypeScript-5.9%2B-blue)](https://www.typescriptlang.org) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-%5E1.26-purple)](https://modelcontextprotocol.io)
-[![npm version](https://img.shields.io/npm/v/@j0hanz/thinkseq-mcp.svg)](https://www.npmjs.com/package/@j0hanz/thinkseq-mcp)[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)[![Powered by MCP](https://img.shields.io/badge/MCP-SDK-blue)](https://github.com/modelcontextprotocol/typescript-sdk)
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0078d7?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%7B%22name%22%3A%22thinkseq%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40j0hanz%2Fthinkseq-mcp%40latest%22%5D%7D) [![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_Server-24bfa5?logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%7B%22name%22%3A%22thinkseq%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40j0hanz%2Fthinkseq-mcp%40latest%22%5D%7D)
-[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=thinkseq&inputs=%5B%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40j0hanz%2Fthinkseq-mcp%40latest%22%5D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=thinkseq&inputs=%5B%5D&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40j0hanz%2Fthinkseq-mcp%40latest%22%5D%7D&quality=insiders)
+A thinking and reasoning engine for the Model Context Protocol (MCP). Enables AI assistants to capture structured, sequential reasoning chains with full revision (destructive rewind) support, session isolation, and progress tracking.
-[![Install in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=thinkseq&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBqMGhhbnovdGhpbmtzZXEtbWNwQGxhdGVzdCJdfQ==)
-An MCP server for structured, sequential thinking with revision support.
+---
 ## Overview
-ThinkSeq exposes a single MCP tool, `thinkseq`, that enables Language Models to "think" in a structured, step-by-step manner. It maintains an in-memory history of thoughts, calculates progress, and critically allows for **destructive revision**—where a model can realize a mistake, "rewind" to a previous step, and branch off with a correction. This capability mirrors human reasoning patterns and improves problem-solving accuracy for complex tasks.
+ThinkSeq provides an MCP server that exposes a single `thinkseq` tool for recording concise thinking steps. Each step is stored in-memory within isolated sessions, and the engine supports revising earlier steps — superseding the target and all subsequent active thoughts while preserving the full audit trail. The server communicates exclusively over **stdio** transport.
+---
 ## Key Features
-- **Sequential Thinking**: Records thoughts as discrete steps with auto-incrementing numbers.
-- **Progress Tracking**: Automatically calculates progress (0.0 to 1.0) based on estimated total thoughts.
-- **Revision Support**: Allows models to revise specific past thoughts, superseding the old path and starting a new reasoning branch.
-- **Context Awareness**: Returns recent thoughts and revision context with every tool call to keep the model grounded.
-- **Session Isolation**: Supports multiple concurrent thinking sessions via `sessionId`.
-- **Memory Management**: Configurable limits for max thoughts and memory usage to prevent resource exhaustion.
+- **Sequential thinking steps** — Record atomic reasoning steps (up to 8,000 characters each) in order
+- **Destructive revision (rewind)** — Revise any active thought; the target and all later thoughts are superseded, continuing from the corrected step
+- **Session isolation** — Multiple independent thought histories via session IDs with pinned LRU eviction (default: 50 sessions)
+- **Progress tracking** — Automatic `progress` (0–1) and `isComplete` signals returned with every response
+---
 ## Tech Stack
-- **Runtime**: Node.js >=22.0.0
-- **Language**: TypeScript 5.9+
-- **MCP SDK**: `@modelcontextprotocol/sdk`
-- **Validation**: `zod`
+| Component       | Technology                               |
+| --------------- | ---------------------------------------- |
+| Runtime         | Node.js ≥ 24                             |
+| Language        | TypeScript 5.9+                          |
+| MCP SDK         | `@modelcontextprotocol/sdk` ^1.26.0      |
+| Validation      | `zod` ^4.3.6                             |
+| Test framework  | Native Node.js Test Runner (`node:test`) |
+| Package manager | npm                                      |
+---
+## Architecture
+1. **CLI** parses arguments (`--max-thoughts`, `--max-memory-mb`, etc.)
+2. **`run()`** resolves dependencies and reads `package.json` for server identity
+3. **McpServer** is created with embedded instructions, the `thinkseq` tool, `internal://instructions` resource, and `get-help` prompt
+4. **StdioServerTransport** connects the server (stdio only)
+5. **Stdio guards** are installed: initialization enforcement, invalid message rejection, parse error responder
+6. **Shutdown handlers** listen for `SIGTERM`/`SIGINT` and gracefully close server, engine, and transport within a configurable timeout
+---
 ## Repository Structure
-```text
-c:\thinkseq-mcp
-├── dist/                 # Compiled JavaScript
+```
+thinkseq-mcp/
 ├── src/
-│   ├── app.ts            # Application entry and MCP wiring
-│   ├── engine.ts         # Core thinking engine logic
-│   ├── engineConfig.ts   # Configuration defaults
-│   ├── index.ts          # CLI entrypoint
-│   ├── lib/              # Utilities (CLI, logging, types)
-│   ├── schemas/          # Zod schemas for inputs/outputs
-│   └── tools/            # MCP tool definitions
+│   ├── appConfig/        # Environment, run dependencies, shutdown, types
+│   ├── engine/           # Revision logic, thought queries, thought store
+│   ├── lib/              # CLI, context, diagnostics, errors, MCP logging, stdio guards
+│   ├── schemas/          # Zod input/output schemas
+│   ├── tools/            # MCP tool registration (thinkseq)
+│   ├── app.ts            # Core application wiring and lifecycle
+│   ├── engine.ts         # ThinkingEngine class (session management, processing)
+│   ├── engineConfig.ts   # Engine constants and defaults
+│   ├── index.ts          # Entry point (CLI → run)
+│   └── instructions.md   # Server instructions (bundled as resource/prompt)
+├── tests/                # Unit and integration tests
+├── scripts/
+│   └── tasks.mjs         # Custom build/test task runner
+├── assets/
+│   └── logo.svg          # Server icon
 ├── package.json
 └── tsconfig.json
 ```
+---
 ## Requirements
-- **Node.js**: Version 22.0.0 or higher.
+- **Node.js** ≥ 24
+- **npm** (included with Node.js)
-## Quickstart
+---
-To run the server using `npx`:
+## Quickstart
 ```bash
 npx -y @j0hanz/thinkseq-mcp@latest
 ```
-<details>
-<summary><b>Quick Test with MCP Inspector</b></summary>
+Add to your MCP client configuration:
-You can inspect the tools using the MCP Inspector:
-```bash
-npx @modelcontextprotocol/inspector npx -y @j0hanz/thinkseq-mcp@latest
+```json
+{
+  "mcpServers": {
+    "thinkseq": {
+      "command": "npx",
+      "args": ["-y", "@j0hanz/thinkseq-mcp@latest"]
+    }
+  }
+}
 ```
-</details>
+---
 ## Installation
-### Using NPX (Recommended)
-This server is designed to be run directly via `npx` in your MCP client configuration.
+### NPX (recommended)
 ```bash
 npx -y @j0hanz/thinkseq-mcp@latest
 ```
-### From Source
+### Global Install
-1. Clone the repository:
+```bash
+npm install -g @j0hanz/thinkseq-mcp
+thinkseq
+```
+### From Source
-   ```bash
-   git clone https://github.com/j0hanz/thinkseq-mcp-server.git
-   cd thinkseq-mcp-server
-   ```
+```bash
+git clone https://github.com/j0hanz/thinkseq-mcp-server.git
+cd thinkseq-mcp-server
+npm install
+npm run build
+npm start
+```
-2. Install dependencies:
+---
-   ```bash
-   npm install
-   ```
+## Configuration
-3. Build the project:
+### CLI Arguments
-   ```bash
-   npm run build
-   ```
+| Flag                                 | Type   | Description                         |
+| ------------------------------------ | ------ | ----------------------------------- |
+| `--max-thoughts <number>`            | number | Max thoughts to keep in memory      |
+| `--max-memory-mb <number>`           | number | Max memory (MB) for stored thoughts |
+| `--shutdown-timeout-ms <number>`     | number | Graceful shutdown timeout (ms)      |
+| `--package-read-timeout-ms <number>` | number | Package.json read timeout (ms)      |
+| `-h`, `--help`                       | flag   | Show help text                      |
-4. Run the server:
+### Engine Defaults
-   ```bash
-   node dist/index.js
-   ```
+| Parameter                 | Default  | Max    |
+| ------------------------- | -------- | ------ |
+| Max thoughts per session  | 500      | 10,000 |
+| Max memory                | 100 MB   | —      |
+| Thought overhead estimate | 200 B    | —      |
+| Max sessions (LRU)        | 50       | 10,000 |
+| Default total thoughts    | 3        | 25     |
+| Default shutdown timeout  | 5,000 ms | —      |
+| Package read timeout      | 2,000 ms | —      |
-## Configuration
+### Environment Variables
-The server is configured via CLI arguments.
+| Variable                        | Default | Description                                                                    |
+| ------------------------------- | ------- | ------------------------------------------------------------------------------ |
+| `THINKSEQ_INCLUDE_TEXT_CONTENT` | `true`  | Set to `0`, `false`, `no`, or `off` to omit JSON string content from responses |
-| Argument                             | Description                                   | Default |
-| :----------------------------------- | :-------------------------------------------- | :------ |
-| `--max-thoughts <number>`            | Max thoughts to keep in memory before pruning | 500     |
-| `--max-memory-mb <number>`           | Max memory (MB) for stored thoughts           | 100     |
-| `--shutdown-timeout-ms <number>`     | Graceful shutdown timeout in ms               | 5000    |
-| `--package-read-timeout-ms <number>` | Package.json read timeout in ms               | 2000    |
-| `-h, --help`                         | Show help message                             | -       |
+---
-## MCP Surface
+## Usage
-### Tools
+### stdio (default and only transport)
-#### `thinkseq`
+```bash
+# Direct
+npx -y @j0hanz/thinkseq-mcp@latest
-Record a concise thinking step. Be brief: capture only the essential insight, calculation, or decision.
+# With options
+npx -y @j0hanz/thinkseq-mcp@latest --max-thoughts 1000 --max-memory-mb 200
+```
-**Parameters:**
+---
-| Name             | Type    | Required | Description                                                                                                           |
-| :--------------- | :------ | :------: | :-------------------------------------------------------------------------------------------------------------------- |
-| `thought`        | string  |   Yes    | Your current thinking step (1-8000 chars).                                                                            |
-| `sessionId`      | string  |    No    | Optional session identifier (max 200 chars) to isolate thought histories.                                             |
-| `totalThoughts`  | integer |    No    | Estimated total thoughts (1-25, default: 3).                                                                          |
-| `revisesThought` | integer |    No    | Revise a previous thought by number. The original is preserved for audit, but the active chain rewinds to this point. |
+## MCP Surface
-**Returns:**
+### Tools
-A JSON object containing the current state of the thinking process, including:
+#### `thinkseq`
-- `thoughtNumber`: The current step number.
-- `progress`: A value between 0 and 1 indicating completion.
-- `isComplete`: Boolean indicating if the thought process is finished.
-- `revisableThoughts`: Array of thought numbers that can be revised.
-- `context`: Recent thoughts and revision information.
+Record a concise thinking step. Supports sequential appending and destructive revision of prior steps.
-**Example Input:**
+**Parameters:**
-```json
-{
-  "thought": "I need to calculate the fibonacci sequence up to 10.",
-  "totalThoughts": 5
-}
-```
+| Name             | Type   | Required | Default     | Description                                                                |
+| ---------------- | ------ | -------- | ----------- | -------------------------------------------------------------------------- |
+| `thought`        | string | Yes      | —           | Your current thinking step (1–8,000 characters)                            |
+| `sessionId`      | string | No       | `"default"` | Session identifier to isolate thought histories (1–200 chars)              |
+| `totalThoughts`  | number | No       | `3`         | Estimated total thoughts (1–25)                                            |
+| `revisesThought` | number | No       | —           | Revise a previous thought by number (≥ 1). Original is preserved for audit |
-**Example Output:**
+**Returns** (structured output):
 ```json
 {
   "ok": true,
   "result": {
     "thoughtNumber": 1,
-    "totalThoughts": 5,
-    "progress": 0.2,
+    "totalThoughts": 3,
+    "progress": 0.333,
     "isComplete": false,
+    "thoughtHistoryLength": 1,
+    "hasRevisions": false,
+    "activePathLength": 1,
     "revisableThoughts": [1],
+    "revisableThoughtsTotal": 1,
     "context": {
       "recentThoughts": [
         {
           "stepIndex": 1,
           "number": 1,
-          "preview": "I need to calculate the fibonacci sequence up to 10."
+          "preview": "First step of reasoning..."
         }
       ]
     }
@@ -179,18 +219,77 @@ A JSON object containing the current state of the thinking process, including:
 }
 ```
+**Revision example:**
+```json
+{
+  "thought": "Better approach: use caching instead",
+  "revisesThought": 2
+}
+```
+Returns additional `revisionInfo` in `context`:
+```json
+{
+  "context": {
+    "recentThoughts": [...],
+    "revisionInfo": {
+      "revises": 2,
+      "supersedes": [2, 3],
+      "supersedesTotal": 2
+    }
+  }
+}
+```
+**Error codes:**
+| Code                           | Description                                |
+| ------------------------------ | ------------------------------------------ |
+| `E_THINK`                      | General processing error                   |
+| `E_REVISION_MISSING`           | `revisesThought` required but not provided |
+| `E_REVISION_TARGET_NOT_FOUND`  | Target thought number does not exist       |
+| `E_REVISION_TARGET_SUPERSEDED` | Target thought was already superseded      |
 ### Resources
-_No resources are currently exposed by this server._
+| URI                       | MIME Type       | Description               |
+| ------------------------- | --------------- | ------------------------- |
+| `internal://instructions` | `text/markdown` | Server usage instructions |
 ### Prompts
-_No prompts are currently exposed by this server._
+| Name       | Description                            |
+| ---------- | -------------------------------------- |
+| `get-help` | Get usage instructions for this server |
+---
 ## Client Configuration Examples
 <details>
-<summary><b>VS Code (mcp.json)</b></summary>
+<summary>VS Code / VS Code Insiders</summary>
+Add to your VS Code MCP settings (`.vscode/mcp.json` or User Settings):
+```json
+{
+  "mcpServers": {
+    "thinkseq": {
+      "command": "npx",
+      "args": ["-y", "@j0hanz/thinkseq-mcp@latest"]
+    }
+  }
+}
+```
+</details>
+<details>
+<summary>Claude Desktop</summary>
+Add to `claude_desktop_config.json`:
 ```json
 {
@@ -206,9 +305,9 @@ _No prompts are currently exposed by this server._
 </details>
 <details>
-<summary><b>Claude Desktop</b></summary>
+<summary>Cursor</summary>
-Add this to your `claude_desktop_config.json`:
+Add to Cursor MCP settings:
 ```json
 {
@@ -221,53 +320,124 @@ Add this to your `claude_desktop_config.json`:
 }
 ```
+Or use the deeplink:
+```
+cursor://anysphere.cursor-deeplink/mcp/install?name=thinkseq&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBqMGhhbnovdGhpbmtzZXEtbWNwQGxhdGVzdCJdfQ==
+```
 </details>
 <details>
-<summary><b>Cursor</b></summary>
+<summary>Windsurf</summary>
-1. Navigate to **Settings** > **General** > **MCP**.
-2. Click **Add New MCP Server**.
-3. Name: `thinkseq`
-4. Type: `command`
-5. Command: `npx -y @j0hanz/thinkseq-mcp@latest`
+Add to `~/.codeium/windsurf/mcp_config.json`:
+```json
+{
+  "mcpServers": {
+    "thinkseq": {
+      "command": "npx",
+      "args": ["-y", "@j0hanz/thinkseq-mcp@latest"]
+    }
+  }
+}
+```
 </details>
+---
 ## Security
-- **Stdio Transport**: This server runs over stdio. It creates a console bridge to intercept `console.log` calls and redirect them to standard error (stderr) to prevent interfering with the JSON-RPC protocol.
-- **Memory Limits**: The server enforces maximum thought counts and memory usage limits (configurable via CLI) to prevent memory exhaustion attacks.
-- **Input Validation**: All inputs are strictly validated using Zod schemas.
+### stdio Transport
+- **stdout protection:** `console.log` and `console.warn` are bridged to MCP logging messages to prevent polluting the JSON-RPC stdio channel.
+- **Initialization enforcement:** The server rejects any request before a valid `initialize` handshake and requires `notifications/initialized` before accepting tool calls.
+- **Invalid message rejection:** Non-object and batch JSON-RPC messages are rejected with proper error codes.
+- **Parse error handling:** Malformed JSON on stdin receives a JSON-RPC Parse Error response.
+### Process Safety
+- Unhandled rejections and uncaught exceptions are caught and result in a clean process exit.
+- Graceful shutdown on `SIGTERM`/`SIGINT` with configurable timeout (default: 5 seconds).
+---
 ## Development Workflow
-1. **Install dependencies**:
+### Install Dependencies
+```bash
+npm install
+```
+### Scripts
+| Script          | Command                                      | Purpose                                                           |
+| --------------- | -------------------------------------------- | ----------------------------------------------------------------- |
+| `dev`           | `tsc --watch --preserveWatchOutput`          | Watch mode TypeScript compilation                                 |
+| `dev:run`       | `node --env-file=.env --watch dist/index.js` | Run built server with auto-reload                                 |
+| `build`         | `node scripts/tasks.mjs build`               | Full build pipeline (clean → compile → validate → assets → chmod) |
+| `start`         | `node dist/index.js`                         | Run the built server                                              |
+| `test`          | `node scripts/tasks.mjs test`                | Run all tests (builds first)                                      |
+| `test:coverage` | `node scripts/tasks.mjs test --coverage`     | Run tests with coverage                                           |
+| `type-check`    | `node scripts/tasks.mjs type-check`          | TypeScript type checking                                          |
+| `lint`          | `eslint .`                                   | Run ESLint                                                        |
+| `lint:fix`      | `eslint . --fix`                             | Auto-fix lint issues                                              |
+| `format`        | `prettier --write .`                         | Format code with Prettier                                         |
+| `clean`         | `node scripts/tasks.mjs clean`               | Remove dist and build info files                                  |
+| `inspector`     | `npx @modelcontextprotocol/inspector`        | Launch MCP Inspector for debugging                                |
+| `knip`          | `knip`                                       | Detect unused exports/dependencies                                |
+---
+## Build and Release
+The build pipeline (`npm run build`) executes:
+1. **Clean** — Remove `dist/` and `.tsbuildinfo` files
+2. **Compile** — TypeScript compilation via `tsconfig.build.json`
+3. **Validate** — Ensure `src/instructions.md` exists
+4. **Copy assets** — Bundle `instructions.md` and `assets/` (including `logo.svg`) into `dist/`
+5. **Make executable** — Set `dist/index.js` to mode `755`
+### Publishing
-   ```bash
-   npm install
-   ```
+Publishing is automated via GitHub Actions (`.github/workflows/publish.yml`):
-2. **Run in development mode**:
+- Triggered on GitHub release publication
+- Pipeline: lint → type-check → test → coverage → build → `npm publish --access public`
+- Uses npm Trusted Publishing (OIDC) for authentication
+---
+## Troubleshooting
+### MCP Inspector
+Use the MCP Inspector to debug and test the server interactively:
+```bash
+npx @modelcontextprotocol/inspector
+```
-   ```bash
-   npm run dev      # Runs tsc in watch mode
-   npm run dev:run  # Runs the built app in watch mode
-   ```
+### Common Issues
-3. **Run tests**:
+| Issue                                              | Solution                                                                                             |
+| -------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| Server not responding                              | Ensure Node.js ≥ 24 is installed; check `node --version`                                             |
+| `initialize must be first request`                 | Client must send `initialize` before any other request                                               |
+| `notifications/initialized must follow initialize` | Client must send `notifications/initialized` after successful `initialize`                           |
+| Thoughts disappearing                              | Check `--max-thoughts` and `--max-memory-mb` limits; old thoughts are pruned when limits are reached |
+| Session not found                                  | Sessions are in-memory only; they reset on server restart. Max 50 sessions by default (LRU eviction) |
-   ```bash
-   npm test
-   ```
+### stdout/stderr Guidance
-4. **Lint and Format**:
+When running as a stdio MCP server, **never write directly to stdout** from custom code — this would corrupt the JSON-RPC protocol. The server automatically bridges `console.log`/`console.warn` to MCP logging. Use `console.error` for debug output that bypasses MCP.
-   ```bash
-   npm run lint
-   npm run format
-   ```
+---
-## Contributing & License
+## License
-This project is licensed under the MIT License.
+[MIT](https://opensource.org/licenses/MIT)

package/dist/app.js CHANGED Viewed

@@ -1,7 +1,8 @@
-import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import process from 'node:process';
 import { resolvePackageIdentity, resolveRunDependencies, } from './appConfig/runDependencies.js';
 import { buildShutdownDependencies } from './appConfig/shutdown.js';
+import { runWithContext } from './lib/context.js';
 import { installConsoleBridge, installMcpLogging } from './lib/mcpLogging.js';
 const toError = (value) => value instanceof Error ? value : new Error(String(value));
 const createExit = (proc, exit) => exit ?? ((code) => proc.exit(code));
@@ -10,10 +11,10 @@ const createHandlerFor = (logError, exit) => (label) => (value) => {
     logError(`thinkseq: ${label}: ${error.message}`);
     exit(1);
 };
-function getLocalIconData() {
+async function getLocalIconData() {
     try {
         const iconPath = new URL('../assets/logo.svg', import.meta.url);
-        const buffer = readFileSync(iconPath);
+        const buffer = await readFile(iconPath);
         if (buffer.length > 2 * 1024 * 1024) {
             console.warn('Warning: logo.svg is larger than 2MB');
         }
@@ -35,15 +36,17 @@ export async function run(deps = {}) {
     const resolved = resolveRunDependencies(deps);
     const pkg = await resolved.readPackageJson(AbortSignal.timeout(resolved.packageReadTimeoutMs));
     const { name, version } = resolvePackageIdentity(pkg);
-    const localIcon = getLocalIconData();
+    const localIcon = await getLocalIconData();
     const server = resolved.createServer(name, version, localIcon);
     installMcpLogging(server);
     const { flush: flushConsole, restore: restoreConsole } = installConsoleBridge(server);
     process.on('exit', restoreConsole);
-    resolved.publishLifecycleEvent({
-        type: 'lifecycle.started',
-        ts: resolved.now(),
-    });
+    runWithContext(() => {
+        resolved.publishLifecycleEvent({
+            type: 'lifecycle.started',
+            ts: resolved.now(),
+        });
+    }, { requestId: 'lifecycle.started' });
     const engine = resolved.engineFactory();
     resolved.registerTool(server, engine, localIcon);
     const transport = await resolved.connectServer(server);

package/dist/appConfig/runDependencies.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { McpServer, ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ThinkingEngine } from '../engine.js';
@@ -9,9 +9,9 @@ import { registerThinkSeq } from '../tools/thinkseq.js';
 import { installShutdownHandlers } from './shutdown.js';
 const INSTRUCTIONS_URL = new URL('../instructions.md', import.meta.url);
 const INSTRUCTIONS_FALLBACK = 'ThinkSeq is a tool for structured, sequential thinking with revision support.';
-function readInstructionsText() {
+async function readInstructionsText() {
     try {
-        return readFileSync(INSTRUCTIONS_URL, { encoding: 'utf8' });
+        return await readFile(INSTRUCTIONS_URL, { encoding: 'utf8' });
     }
     catch {
         return INSTRUCTIONS_FALLBACK;
@@ -21,28 +21,34 @@ function loadServerInstructions(raw) {
     const trimmed = raw.trim();
     return trimmed.length > 0 ? trimmed : INSTRUCTIONS_FALLBACK;
 }
-function registerInstructionsResource(server) {
-    server.registerResource('instructions', new ResourceTemplate('internal://instructions', {
-        list: () => ({
-            resources: [
-                {
-                    uri: 'internal://instructions',
-                    name: 'Instructions',
-                    mimeType: 'text/markdown',
-                },
-            ],
-        }),
-    }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
-        contents: [
+const INSTRUCTIONS_RESOURCE_TEMPLATE = new ResourceTemplate('internal://instructions', {
+    list: () => ({
+        resources: [
             {
-                uri: uri.href,
-                text: INSTRUCTIONS_TEXT,
+                uri: 'internal://instructions',
+                name: 'Instructions',
                 mimeType: 'text/markdown',
             },
         ],
-    }));
+    }),
+});
+const INSTRUCTIONS_METADATA = {
+    title: 'Instructions',
+    mimeType: 'text/markdown',
+};
+const readInstructionsResource = (uri) => ({
+    contents: [
+        {
+            uri: uri.href,
+            text: INSTRUCTIONS_TEXT,
+            mimeType: 'text/markdown',
+        },
+    ],
+});
+function registerInstructionsResource(server) {
+    server.registerResource('instructions', INSTRUCTIONS_RESOURCE_TEMPLATE, INSTRUCTIONS_METADATA, readInstructionsResource);
 }
-const INSTRUCTIONS_TEXT = readInstructionsText();
+const INSTRUCTIONS_TEXT = await readInstructionsText();
 const SERVER_INSTRUCTIONS = loadServerInstructions(INSTRUCTIONS_TEXT);
 const DEFAULT_PACKAGE_READ_TIMEOUT_MS = 2000;
 function buildServerCapabilities(overrides = {}) {

package/dist/appConfig/shutdown.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { runWithContext } from '../lib/context.js';
 import { publishLifecycleEvent } from '../lib/diagnostics.js';
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
 function isRecord(value) {
@@ -35,11 +36,13 @@ function buildShutdownRunner(deps, proc) {
         if (shuttingDown)
             return;
         shuttingDown = true;
-        emit({
-            type: 'lifecycle.shutdown',
-            ts: timestamp(),
-            signal,
-        });
+        runWithContext(() => {
+            emit({
+                type: 'lifecycle.shutdown',
+                ts: timestamp(),
+                signal,
+            });
+        }, { requestId: `lifecycle.shutdown:${signal}` });
         await closeAllWithinTimeout([deps.server, deps.engine, deps.transport], timeoutMs);
         proc.exit(0);
     };

package/dist/engine/thoughtStore.d.ts CHANGED Viewed

@@ -24,7 +24,7 @@ export declare class ThoughtStore {
         supersedesTotal: number;
     };
     getActiveThoughts(): readonly StoredThought[];
-    getActiveThoughtNumbers(max?: number): number[];
+    getActiveThoughtNumbers(max?: number): readonly number[];
     getThoughtByNumber(thoughtNumber: number): StoredThought | undefined;
     getTotalLength(): number;
     pruneHistoryIfNeeded(): void;

package/dist/engine.js CHANGED Viewed

@@ -31,22 +31,20 @@ class PinnedLruSessions {
         this.#evictIfNeeded();
     }
     #evictIfNeeded() {
-        while (this.#map.size > this.#max) {
-            const oldestKey = this.#map.keys().next().value;
-            if (!oldestKey)
-                return;
-            if (oldestKey === this.#pinnedKey) {
+        if (this.#map.size <= this.#max)
+            return;
+        for (const key of this.#map.keys()) {
+            if (this.#map.size <= this.#max)
+                break;
+            if (key === this.#pinnedKey) {
                 const pinned = this.#map.get(this.#pinnedKey);
-                if (!pinned) {
-                    // Invariant broken; safest is to stop evicting.
-                    return;
+                if (pinned) {
+                    this.#map.delete(this.#pinnedKey);
+                    this.#map.set(this.#pinnedKey, pinned);
                 }
-                // Move pinned to most-recent and try again.
-                this.#map.delete(this.#pinnedKey);
-                this.#map.set(this.#pinnedKey, pinned);
                 continue;
             }
-            this.#map.delete(oldestKey);
+            this.#map.delete(key);
         }
     }
 }
@@ -145,7 +143,7 @@ export class ThinkingEngine {
             ...(details.revisionOf !== undefined && {
                 revisionOf: details.revisionOf,
             }),
-            byteLength: Buffer.byteLength(input.thought),
+            byteLength: Buffer.byteLength(input.thought, 'utf8'),
         };
     }
     #resolveEffectiveTotalThoughts(store, input, fallback) {

package/dist/instructions.md CHANGED Viewed

@@ -1,43 +1,56 @@
 # ThinkSeq Instructions
-> Guidance for the Agent: These instructions are available as a resource (`internal://instructions`) or prompt (`get-help`). Load them when you are unsure about tool usage.
+> Available as resource (`internal://instructions`) or prompt (`get-help`). Load when unsure about tool usage.
-## 1. Core Capability
+---
-- **Domain:** In-memory, sequential thinking with revision (destructive rewind) per session.
-- **Primary Resources:** `Thoughts`, `RevisionChain`, `ProgressContext`.
+## CORE CAPABILITY
-## 2. The "Golden Path" Workflows (Critical)
+- Domain: In-memory, sequential thinking with revision (destructive rewind) per session.
+- Primary Resources: `Thoughts`, `RevisionChain`, `ProgressContext`.
+- Tools: `thinkseq` (WRITE)
-_Describe the standard order of operations using ONLY tools that exist._
+---
-### Workflow A: Capture a reasoning chain
+## THE "GOLDEN PATH" WORKFLOWS (CRITICAL)
-1. Call `thinkseq` with `thought` (optionally `totalThoughts`, `sessionId`).
+### WORKFLOW A: Capture a reasoning chain
+1. Call `thinkseq` with: `{ "thought": "..." }` (optionally `totalThoughts`, `sessionId`).
 2. Continue calling `thinkseq` for each step.
 3. Read `progress` and `isComplete` from the output to know when to stop.
-   > Constraint: Keep each step atomic; one decision per call.
+   NOTE: Keep each step atomic; one decision per call.
-### Workflow B: Revise a prior step
+### WORKFLOW B: Revise a prior step
 1. Call `thinkseq` to get the latest `revisableThoughts` list (returned in every response).
 2. Call `thinkseq` again with `revisesThought` set to a valid entry from that list.
 3. Continue from the revised step.
-   > Constraint: Never guess `revisesThought`; always pick from `revisableThoughts`.
+   NOTE: Never guess `revisesThought`; always pick from `revisableThoughts`.
+---
+## TOOL NUANCES & GOTCHAS
+`thinkseq`
+- Purpose: Append or revise a thought in the current session.
+- Inputs: `thought` (1–8000 chars), `totalThoughts` (1–25), `revisesThought` (int ≥ 1).
+- Side effects: Mutates in-memory thought history; revisions supersede the target and later active thoughts (destructive rewind).
+- Defaults: If `totalThoughts` is omitted, the engine uses 3 or the last active total.
+- Compatibility: Set `THINKSEQ_INCLUDE_TEXT_CONTENT=0` env var to omit JSON string content if needed.
+---
-## 3. Tool Nuances & Gotchas
+## ERROR HANDLING STRATEGY
-_Do NOT repeat JSON schema. Focus on behavior and pitfalls._
+- `E_REVISION_MISSING` / `E_REVISION_TARGET_NOT_FOUND`: Fetch `revisableThoughts` and retry with a valid ID.
+- `E_REVISION_TARGET_SUPERSEDED`: Target already superseded; pick an active thought from `revisableThoughts`.
+- `E_THINK`: Verify inputs and retry once.
+- `E_TIMEOUT`: Reduce thought length.
-- **`thinkseq`**
-  - **Purpose:** Append or revise a thought in the current session.
-  - **Inputs:** `thought` (1–8000 chars), `totalThoughts` (1–25), `revisesThought` (int ≥ 1).
-  - **Side effects:** Mutates in-memory thought history; revisions supersede the target and later active thoughts (destructive rewind).
-  - **Defaults:** If `totalThoughts` is omitted, the engine uses 3 or the last active total.
-  - **Compatibility:** Set `THINKSEQ_INCLUDE_TEXT_CONTENT=0` env var to omit JSON string content if needed.
+---
-## 4. Error Handling Strategy
+## RESOURCES
-- **`E_REVISION_MISSING` / `E_REVISION_TARGET_NOT_FOUND`**: Fetch `revisableThoughts` and retry with a valid ID.
-- **`E_THINK`**: Verify inputs and retry once.
-- **`E_TIMEOUT`**: Reduce thought length.
+- `internal://instructions`: This document.

package/dist/lib/context.js CHANGED Viewed

@@ -3,11 +3,19 @@ import { randomUUID } from 'node:crypto';
 import { performance } from 'node:perf_hooks';
 const storage = new AsyncLocalStorage();
 export function runWithContext(callback, context) {
+    const current = storage.getStore();
     const store = {
-        requestId: context?.requestId ?? randomUUID(),
-        startedAt: context?.startedAt ?? performance.now(),
-        startedAtEpochMs: context?.startedAtEpochMs ?? Date.now(),
+        requestId: context?.requestId ?? current?.requestId ?? randomUUID(),
+        startedAt: context?.startedAt ?? current?.startedAt ?? performance.now(),
+        startedAtEpochMs: context?.startedAtEpochMs ?? current?.startedAtEpochMs ?? Date.now(),
     };
+    if (!current)
+        return storage.run(store, callback);
+    if (current.requestId === store.requestId &&
+        current.startedAt === store.startedAt &&
+        current.startedAtEpochMs === store.startedAtEpochMs) {
+        return callback();
+    }
     return storage.run(store, callback);
 }
 export function getRequestContext() {

package/dist/lib/diagnostics.d.ts CHANGED Viewed

@@ -25,7 +25,7 @@ type ToolEventBase = {
 export type ToolEvent = ToolEventBase & {
     context?: EventContext;
 };
-export type LifecycleEvent = {
+type LifecycleEventBase = {
     type: 'lifecycle.started';
     ts: number;
 } | {
@@ -33,6 +33,9 @@ export type LifecycleEvent = {
     ts: number;
     signal: string;
 };
+export type LifecycleEvent = LifecycleEventBase & {
+    context?: EventContext;
+};
 export declare function publishToolEvent(event: ToolEvent): void;
 export declare function publishLifecycleEvent(event: LifecycleEvent): void;
 export {};

package/dist/lib/diagnostics.js CHANGED Viewed

@@ -30,5 +30,5 @@ export function publishToolEvent(event) {
     safePublish(toolChannel, attachContext(event));
 }
 export function publishLifecycleEvent(event) {
-    safePublish(lifecycleChannel, event);
+    safePublish(lifecycleChannel, attachContext(event));
 }

package/dist/lib/errors.d.ts CHANGED Viewed

@@ -13,8 +13,5 @@ export interface ErrorResponse extends Record<string, unknown> {
     };
     isError: true;
 }
-export interface CreateErrorResponseOptions {
-    includeTextContent?: boolean;
-}
 export declare function getErrorMessage(error: unknown): string;
-export declare function createErrorResponse(code: string, message: string, result?: unknown, options?: CreateErrorResponseOptions): ErrorResponse;
+export declare function createErrorResponse(code: string, message: string, result?: unknown): ErrorResponse;

package/dist/lib/errors.js CHANGED Viewed

@@ -1,21 +1,22 @@
+import { inspect } from 'node:util';
 export function getErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
     if (typeof error === 'string' && error.length > 0)
         return error;
+    if (error !== null && error !== undefined) {
+        return inspect(error, { depth: 2, breakLength: 120, maxArrayLength: 20 });
+    }
     return 'Unknown error';
 }
-export function createErrorResponse(code, message, result, options = {}) {
+export function createErrorResponse(code, message, result) {
     const structured = {
         ok: false,
         error: { code, message },
         ...(result !== undefined && { result }),
     };
-    const includeTextContent = options.includeTextContent ?? true;
     const response = {
-        content: includeTextContent
-            ? [{ type: 'text', text: JSON.stringify(structured) }]
-            : [],
+        content: [{ type: 'text', text: JSON.stringify(structured) }],
         structuredContent: structured,
         isError: true,
     };

package/dist/lib/mcpLogging.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import diagnosticsChannel from 'node:diagnostics_channel';
+import { format } from 'node:util';
 const TOOL_LOGGER = 'thinkseq.tool';
 const LIFECYCLE_LOGGER = 'thinkseq.lifecycle';
 const toolChannel = diagnosticsChannel.channel('thinkseq:tool');
@@ -58,37 +59,52 @@ export function installMcpLogging(target) {
         lifecycleChannel.unsubscribe(onLifecycle);
     };
 }
-function createConsoleSender(target) {
+function createConsoleSender(target, level) {
     return (text) => {
         void target
-            .sendLoggingMessage({ level: 'info', logger: 'console', data: text })
+            .sendLoggingMessage({ level, logger: 'console', data: text })
             .catch(() => undefined);
     };
 }
 export function installConsoleBridge(target) {
     const buffer = [];
     let isReady = false;
-    const send = createConsoleSender(target);
+    const sendInfo = createConsoleSender(target, 'info');
+    const sendWarn = createConsoleSender(target, 'warning');
     const originalLog = console.log;
+    const originalWarn = console.warn;
     console.log = (...args) => {
-        const text = args
-            .map((a) => (typeof a === 'string' ? a : JSON.stringify(a)))
-            .join(' ');
+        const text = format(...args);
         if (isReady) {
-            send(text);
+            sendInfo(text);
         }
         else {
-            buffer.push(text);
+            buffer.push({ level: 'info', text });
+        }
+    };
+    console.warn = (...args) => {
+        const text = format(...args);
+        if (isReady) {
+            sendWarn(text);
+        }
+        else {
+            buffer.push({ level: 'warning', text });
         }
     };
     return {
         flush: () => {
             isReady = true;
-            buffer.forEach(send);
+            buffer.forEach((item) => {
+                if (item.level === 'info')
+                    sendInfo(item.text);
+                else
+                    sendWarn(item.text);
+            });
             buffer.length = 0;
         },
         restore: () => {
             console.log = originalLog;
+            console.warn = originalWarn;
         },
     };
 }

package/dist/lib/stdioGuards.js CHANGED Viewed

@@ -1,5 +1,8 @@
 import { ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { getRequestContext, runWithContext } from './context.js';
 const INIT_FIRST_ERROR_MESSAGE = 'initialize must be the first request';
+const INITIALIZED_NOTIFICATION_METHOD = 'notifications/initialized';
+const INIT_NOTIFICATION_REQUIRED_MESSAGE = 'notifications/initialized must follow initialize';
 function isStdioMessageTransport(value) {
     if (!value || typeof value !== 'object')
         return false;
@@ -43,6 +46,29 @@ function parseJsonRpcResponse(message) {
     const { error } = message;
     return { id, error: hasError ? error : undefined };
 }
+function resolveMessageRequestId(message) {
+    const methodMessage = parseJsonRpcMethodMessage(message);
+    if (methodMessage?.hasId && methodMessage.id !== null) {
+        return String(methodMessage.id);
+    }
+    const response = parseJsonRpcResponse(message);
+    if (response && response.id !== null) {
+        return String(response.id);
+    }
+    return undefined;
+}
+function withMessageContext(message, handler) {
+    if (getRequestContext()) {
+        handler();
+        return;
+    }
+    const requestId = resolveMessageRequestId(message);
+    if (requestId) {
+        runWithContext(handler, { requestId });
+        return;
+    }
+    runWithContext(handler);
+}
 function getIdKey(id) {
     return id === null ? 'null' : String(id);
 }
@@ -97,32 +123,51 @@ function trackInitializeResponse(message, state) {
 function handleInitializeMethod(methodMessage, state, originalOnMessage, message, extra) {
     state.pendingInitIds.add(getIdKey(methodMessage.id));
     originalOnMessage(message, extra);
-    return true;
+}
+function handleInitializedNotification(state, originalOnMessage, message, extra) {
+    if (!state.sawInitialize)
+        return;
+    state.sawInitializedNotification = true;
+    originalOnMessage(message, extra);
 }
 function handleNonInitializedRequest(methodMessage, transport) {
     if (methodMessage.hasId) {
         sendError(transport, ErrorCode.InvalidRequest, INIT_FIRST_ERROR_MESSAGE, methodMessage.id);
     }
-    return true;
+}
+function handleMissingInitializedNotification(methodMessage, transport) {
+    if (methodMessage.hasId) {
+        sendError(transport, ErrorCode.InvalidRequest, INIT_NOTIFICATION_REQUIRED_MESSAGE, methodMessage.id);
+    }
 }
 function createInitGuardHandler(state, originalOnMessage, transport) {
     return (message, extra) => {
-        const methodMessage = parseJsonRpcMethodMessage(message);
-        if (!methodMessage) {
-            originalOnMessage(message, extra);
-            return;
-        }
-        if (methodMessage.method === 'initialize') {
-            if (!methodMessage.hasId)
+        withMessageContext(message, () => {
+            const methodMessage = parseJsonRpcMethodMessage(message);
+            if (!methodMessage) {
+                originalOnMessage(message, extra);
                 return;
-            handleInitializeMethod(methodMessage, state, originalOnMessage, message, extra);
-            return;
-        }
-        if (!state.sawInitialize) {
-            handleNonInitializedRequest(methodMessage, transport);
-            return;
-        }
-        originalOnMessage(message, extra);
+            }
+            if (methodMessage.method === 'initialize') {
+                if (!methodMessage.hasId)
+                    return;
+                handleInitializeMethod(methodMessage, state, originalOnMessage, message, extra);
+                return;
+            }
+            if (methodMessage.method === INITIALIZED_NOTIFICATION_METHOD) {
+                handleInitializedNotification(state, originalOnMessage, message, extra);
+                return;
+            }
+            if (!state.sawInitialize) {
+                handleNonInitializedRequest(methodMessage, transport);
+                return;
+            }
+            if (!state.sawInitializedNotification) {
+                handleMissingInitializedNotification(methodMessage, transport);
+                return;
+            }
+            originalOnMessage(message, extra);
+        });
     };
 }
 export function installStdioInitializationGuards(transport) {
@@ -133,6 +178,7 @@ export function installStdioInitializationGuards(transport) {
         return;
     const state = {
         sawInitialize: false,
+        sawInitializedNotification: false,
         pendingInitIds: new Set(),
     };
     wrapSendForInitTracking(transport, state);
@@ -145,13 +191,15 @@ export function installStdioInvalidMessageGuards(transport) {
     if (!originalOnMessage)
         return;
     transport.onmessage = (message, extra) => {
-        // MCP stdio is line-delimited JSON-RPC (one object per line). JSON-RPC
-        // batching is removed in newer revisions; treat arrays as invalid.
-        if (isInvalidJsonRpcMessageShape(message)) {
-            sendError(transport, ErrorCode.InvalidRequest, 'Invalid Request');
-            return;
-        }
-        originalOnMessage(message, extra);
+        withMessageContext(message, () => {
+            // MCP stdio is line-delimited JSON-RPC (one object per line). JSON-RPC
+            // batching is removed in newer revisions; treat arrays as invalid.
+            if (isInvalidJsonRpcMessageShape(message)) {
+                sendError(transport, ErrorCode.InvalidRequest, 'Invalid Request');
+                return;
+            }
+            originalOnMessage(message, extra);
+        });
     };
 }
 export function installStdioParseErrorResponder(transport) {

package/dist/lib/types.d.ts CHANGED Viewed

@@ -37,7 +37,7 @@ export type ProcessResult = {
         thoughtHistoryLength: number;
         hasRevisions: boolean;
         activePathLength: number;
-        revisableThoughts: number[];
+        revisableThoughts: readonly number[];
         revisableThoughtsTotal: number;
         context: ContextSummary;
     };

package/dist/tools/thinkseq.js CHANGED Viewed

@@ -1,5 +1,4 @@
 import { performance } from 'node:perf_hooks';
-import { APP_ENV } from '../appConfig/env.js';
 import { runWithContext } from '../lib/context.js';
 import { publishToolEvent } from '../lib/diagnostics.js';
 import { createErrorResponse, getErrorMessage } from '../lib/errors.js';
@@ -40,16 +39,17 @@ function finalizeToolEvent(outcome, durationMs, extra) {
     });
     void sendProgress(extra, 1, 'failed');
 }
-function buildErrorResponse(code, message, includeTextContent) {
-    return createErrorResponse(code, message, undefined, { includeTextContent });
+function buildErrorResponse(code, message) {
+    return createErrorResponse(code, message);
 }
-function buildToolResponse(result, options) {
+function buildToolResponse(result) {
     if (!result.ok)
-        return buildErrorResponse(result.error.code, result.error.message, options.includeTextContent);
+        return buildErrorResponse(result.error.code, result.error.message);
     const structured = {
         ok: true,
         result: {
             ...result.result,
+            revisableThoughts: [...result.result.revisableThoughts],
             context: {
                 ...result.result.context,
                 recentThoughts: [...result.result.context.recentThoughts],
@@ -57,9 +57,7 @@ function buildToolResponse(result, options) {
         },
     };
     return {
-        content: options.includeTextContent
-            ? [{ type: 'text', text: JSON.stringify(structured) }]
-            : [],
+        content: [{ type: 'text', text: JSON.stringify(structured) }],
         structuredContent: structured,
     };
 }
@@ -111,7 +109,7 @@ function resolveSessionId(input, extra) {
         return String(found);
     return 'default';
 }
-async function processThoughtWithTiming(engine, sessionId, normalized, extra, includeTextContent) {
+async function processThoughtWithTiming(engine, sessionId, normalized, extra) {
     publishToolEvent({ type: 'tool.start', tool: 'thinkseq', ts: Date.now() });
     const start = performance.now();
     void sendProgress(extra, 0, 'started');
@@ -121,10 +119,10 @@ async function processThoughtWithTiming(engine, sessionId, normalized, extra, in
             : engine.processThought(normalized));
         const durationMs = getDurationMs(start);
         handleThoughtResult(result, durationMs, extra);
-        return buildToolResponse(result, { includeTextContent });
+        return buildToolResponse(result);
     }
     catch (err) {
-        return handleThoughtError(err, start, extra, includeTextContent);
+        return handleThoughtError(err, start, extra);
     }
 }
 function handleThoughtResult(result, durationMs, extra) {
@@ -138,11 +136,11 @@ function handleThoughtResult(result, durationMs, extra) {
         errorMessage: result.error.message,
     }, durationMs, extra);
 }
-function handleThoughtError(err, start, extra, includeTextContent) {
+function handleThoughtError(err, start, extra) {
     const errorMessage = getErrorMessage(err);
     const durationMs = getDurationMs(start);
     finalizeToolEvent({ ok: false, errorCode: 'E_THINK', errorMessage }, durationMs, extra);
-    return buildErrorResponse('E_THINK', errorMessage, includeTextContent);
+    return buildErrorResponse('E_THINK', errorMessage);
 }
 function buildThoughtData(input) {
     return {
@@ -159,10 +157,9 @@ async function handleThinkSeq(engine, input, extra) {
     const requestId = extra?.requestId;
     const context = requestId === undefined ? undefined : { requestId: String(requestId) };
     return runWithContext(async () => {
-        const includeTextContent = APP_ENV.INCLUDE_TEXT_CONTENT;
         const normalized = buildThoughtData(input);
         const sessionId = resolveSessionId(input, extra);
-        return processThoughtWithTiming(engine, sessionId, normalized, extra, includeTextContent);
+        return processThoughtWithTiming(engine, sessionId, normalized, extra);
     }, context);
 }
 export function registerThinkSeq(server, engine, icon) {

package/package.json CHANGED Viewed

@@ -1,15 +1,18 @@
 {
   "name": "@j0hanz/thinkseq-mcp",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "mcpName": "io.github.j0hanz/thinkseq",
   "description": "An thinking and reasoning engine for the Model Context Protocol (MCP).",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
   },
-  "sideEffects": false,
   "bin": {
     "thinkseq": "dist/index.js"
   },
@@ -53,13 +56,13 @@
   "homepage": "https://github.com/j0hanz/thinkseq-mcp-server#readme",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
-    "@types/node": "^25.2.0",
+    "@types/node": "^24",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-de-morgan": "^2.0.0",
@@ -72,6 +75,6 @@
     "typescript-eslint": "^8.54.0"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24"
   }
 }