@j0hanz/thinkseq-mcp 1.2.1 → 1.2.3

package/README.md

@@ -268,7 +268,7 @@ Output:
 
 ## Behavior and validation
 
-- Inputs are validated with Zod and unknown keys are stripped (ignored).
+- Inputs are validated with Zod and unknown keys are rejected.
 - `thoughtNumber` is auto-incremented (1, 2, 3...).
 - `totalThoughts` defaults to 3, must be in 1-25, and is adjusted up to at least `thoughtNumber`.
 - The engine stores thoughts in memory and prunes when limits are exceeded:
@@ -282,7 +282,6 @@ This server publishes events via `node:diagnostics_channel`:
 
 - `thinkseq:tool` for `tool.start` and `tool.end` (includes duration, errors, and request context).
 - `thinkseq:lifecycle` for `lifecycle.started` and `lifecycle.shutdown`.
-- `thinkseq:engine` for internal engine events such as `engine.sequence_gap`.
 
 ## Configuration
 

package/dist/app.js

@@ -1,5 +1,4 @@
 import { buildShutdownDependencies, resolvePackageIdentity, resolveRunDependencies, } from './appConfig.js';
-import { installInitializationGuards } from './lib/protocolGuards.js';
 const toError = (value) => value instanceof Error ? value : new Error(String(value));
 const createExit = (proc, exit) => exit ?? ((code) => proc.exit(code));
 const createHandlerFor = (logError, exit) => (label) => (value) => {
@@ -26,7 +25,6 @@ export async function run(deps = {}) {
     const server = resolved.createServer(name, version);
     const engine = resolved.engineFactory();
     resolved.registerTool(server, engine);
-    installInitializationGuards(server);
     const transport = await resolved.connectServer(server);
     resolved.installShutdownHandlers(buildShutdownDependencies(resolved, { server, engine, transport }));
 }

package/dist/appConfig/runDependencies.js

@@ -1,23 +1,23 @@
+import { readFileSync } from 'node:fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { readFileSync } from 'node:fs';
 import { ThinkingEngine } from '../engine.js';
 import { publishLifecycleEvent } from '../lib/diagnostics.js';
 import { readSelfPackageJson } from '../lib/package.js';
-import { installStdioInvalidMessageGuards, installStdioParseErrorResponder, } from '../lib/stdioGuards.js';
+import { installStdioInitializationGuards, installStdioInvalidMessageGuards, installStdioParseErrorResponder, } from '../lib/stdioGuards.js';
 import { registerThinkSeq } from '../tools/thinkseq.js';
 import { installShutdownHandlers } from './shutdown.js';
-const DEFAULT_SERVER_INSTRUCTIONS = 'ThinkSeq is a tool for structured, sequential thinking with revision support.';
 function loadServerInstructions() {
+    const fallback = 'ThinkSeq is a tool for structured, sequential thinking with revision support.';
     try {
         const raw = readFileSync(new URL('../instructions.md', import.meta.url), {
             encoding: 'utf8',
         });
         const trimmed = raw.trim();
-        return trimmed.length > 0 ? trimmed : DEFAULT_SERVER_INSTRUCTIONS;
+        return trimmed.length > 0 ? trimmed : fallback;
     }
     catch {
-        return DEFAULT_SERVER_INSTRUCTIONS;
+        return fallback;
     }
 }
 const SERVER_INSTRUCTIONS = loadServerInstructions();
@@ -31,43 +31,26 @@ const defaultCreateServer = (name, version) => {
 const defaultConnectServer = async (server, createTransport = () => new StdioServerTransport()) => {
     const transport = createTransport();
     await server.connect(transport);
+    installStdioInitializationGuards(transport);
     installStdioInvalidMessageGuards(transport);
     installStdioParseErrorResponder(transport);
     return transport;
 };
-function resolveCoreDependencies(deps) {
+export function resolveRunDependencies(deps) {
     return {
         processLike: deps.processLike ?? process,
         packageReadTimeoutMs: deps.packageReadTimeoutMs ?? DEFAULT_PACKAGE_READ_TIMEOUT_MS,
         readPackageJson: deps.readPackageJson ?? readSelfPackageJson,
         publishLifecycleEvent: deps.publishLifecycleEvent ?? publishLifecycleEvent,
-        now: deps.now ?? Date.now,
-    };
-}
-function resolveServerDependencies(deps) {
-    return {
         createServer: deps.createServer ?? defaultCreateServer,
         connectServer: deps.connectServer ?? defaultConnectServer,
-    };
-}
-function resolveEngineDependencies(deps) {
-    return {
         registerTool: deps.registerTool ?? registerThinkSeq,
         engineFactory: deps.engineFactory ?? (() => new ThinkingEngine()),
         installShutdownHandlers: deps.installShutdownHandlers ?? installShutdownHandlers,
-    };
-}
-function resolveShutdownTimeout(deps) {
-    if (deps.shutdownTimeoutMs === undefined)
-        return {};
-    return { shutdownTimeoutMs: deps.shutdownTimeoutMs };
-}
-export function resolveRunDependencies(deps) {
-    return {
-        ...resolveCoreDependencies(deps),
-        ...resolveServerDependencies(deps),
-        ...resolveEngineDependencies(deps),
-        ...resolveShutdownTimeout(deps),
+        now: deps.now ?? Date.now,
+        ...(deps.shutdownTimeoutMs !== undefined
+            ? { shutdownTimeoutMs: deps.shutdownTimeoutMs }
+            : {}),
     };
 }
 export function resolvePackageIdentity(pkg) {

package/dist/appConfig/shutdown.js

@@ -6,17 +6,24 @@ function isRecord(value) {
 function hasClose(value) {
     return isRecord(value) && typeof value.close === 'function';
 }
-async function closeWithTimeout(value, timeoutMs) {
+async function closeSafely(value) {
+    try {
+        if (hasClose(value))
+            await value.close();
+    }
+    catch {
+        return;
+    }
+}
+async function closeAllWithinTimeout(values, timeoutMs) {
     const timeout = new Promise((resolve) => setTimeout(resolve, timeoutMs));
-    const attempt = (async () => {
-        try {
-            if (hasClose(value))
-                await value.close();
-        }
-        catch {
-            return;
-        }
-    })();
+    const attempt = Promise.allSettled(values.map((value) => closeSafely(value)))
+        .then(() => {
+        return;
+    })
+        .catch(() => {
+        return;
+    });
     await Promise.race([attempt, timeout]);
 }
 function buildShutdownRunner(deps, proc) {
@@ -33,9 +40,7 @@ function buildShutdownRunner(deps, proc) {
             ts: timestamp(),
             signal,
         });
-        await closeWithTimeout(deps.server, timeoutMs);
-        await closeWithTimeout(deps.engine, timeoutMs);
-        await closeWithTimeout(deps.transport, timeoutMs);
+        await closeAllWithinTimeout([deps.server, deps.engine, deps.transport], timeoutMs);
         proc.exit(0);
     };
 }

package/dist/appConfig/types.d.ts

@@ -1,9 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ThinkingEngine } from '../engine.js';
-export type CloseFn = () => Promise<void> | void;
+export type { CloseFn, EngineLike } from '../lib/types.js';
 export type ProcessLike = Pick<typeof process, 'on' | 'exit'>;
 export type TransportLike = Parameters<McpServer['connect']>[0];
 export type ServerLike = Pick<McpServer, 'connect' | 'registerTool'>;
-export type EngineLike = Pick<ThinkingEngine, 'processThought'> & {
-    close?: CloseFn;
-};

package/dist/engine/revision.js

@@ -1,23 +1,16 @@
 export function resolveRevisionTarget(input, getThoughtByNumber) {
-    const targetNumberResult = getRevisionTargetNumber(input);
-    if (!targetNumberResult.ok) {
-        return targetNumberResult;
+    const targetNumber = input.revisesThought;
+    if (targetNumber === undefined) {
+        return {
+            ok: false,
+            error: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
+        };
     }
-    const validationError = validateRevisionTarget(getThoughtByNumber, targetNumberResult.targetNumber);
+    const validationError = validateRevisionTarget(getThoughtByNumber, targetNumber);
     if (validationError) {
         return { ok: false, error: validationError };
     }
-    return { ok: true, targetNumber: targetNumberResult.targetNumber };
-}
-function getRevisionTargetNumber(input) {
-    const targetNumber = input.revisesThought;
-    if (targetNumber !== undefined) {
-        return { ok: true, targetNumber };
-    }
-    return {
-        ok: false,
-        error: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
-    };
+    return { ok: true, targetNumber };
 }
 function validateRevisionTarget(getThoughtByNumber, targetNumber) {
     const target = getThoughtByNumber(targetNumber);

package/dist/engine/thoughtQueries.js

@@ -1,10 +1,5 @@
-function getRecentActiveThoughts(activeThoughts, limit) {
-    if (limit <= 0)
-        return [];
-    return activeThoughts.slice(-limit);
-}
 export function buildContextSummary(activeThoughts, revisionInfo) {
-    const recent = getRecentActiveThoughts(activeThoughts, 5);
+    const recent = activeThoughts.slice(-5);
     const startIndex = activeThoughts.length - recent.length;
     const recentThoughts = recent.map((thought, index) => ({
         stepIndex: startIndex + index + 1,

package/dist/engine/thoughtStore.js

@@ -4,6 +4,7 @@ export class ThoughtStore {
     #thoughtIndex = new Map();
     #activeThoughts = [];
     #activeThoughtNumbers = [];
+    #activeMaxTotalThoughts = 0;
     #headIndex = 0;
     #nextThoughtNumber = 1;
     #estimatedBytes = 0;
@@ -18,9 +19,10 @@ export class ThoughtStore {
     nextThoughtNumbers(totalThoughts) {
         const thoughtNumber = this.#nextThoughtNumber;
         this.#nextThoughtNumber += 1;
+        const effectiveTotalThoughts = Math.max(totalThoughts, thoughtNumber, this.#activeMaxTotalThoughts);
         return {
             thoughtNumber,
-            totalThoughts: Math.max(totalThoughts, thoughtNumber),
+            totalThoughts: effectiveTotalThoughts,
         };
     }
     storeThought(stored) {
@@ -29,9 +31,17 @@ export class ThoughtStore {
         if (stored.isActive) {
             this.#activeThoughts.push(stored);
             this.#activeThoughtNumbers.push(stored.thoughtNumber);
+            this.#activeMaxTotalThoughts = Math.max(this.#activeMaxTotalThoughts, stored.totalThoughts);
         }
         this.#estimatedBytes += this.#estimateThoughtBytes(stored);
     }
+    #recomputeActiveMaxTotalThoughts() {
+        let maxTotal = 0;
+        for (const thought of this.#activeThoughts) {
+            maxTotal = Math.max(maxTotal, thought.totalThoughts);
+        }
+        this.#activeMaxTotalThoughts = maxTotal;
+    }
     #findActiveThoughtIndex(thoughtNumber) {
         const activeThoughtNumbers = this.#activeThoughtNumbers;
         let low = 0;
@@ -71,6 +81,7 @@ export class ThoughtStore {
         }
         this.#activeThoughts.length = startIndex;
         this.#activeThoughtNumbers.length = startIndex;
+        this.#recomputeActiveMaxTotalThoughts();
         return supersedes;
     }
     getActiveThoughts() {
@@ -114,6 +125,7 @@ export class ThoughtStore {
             return;
         this.#activeThoughts = this.#activeThoughts.slice(startIndex);
         this.#activeThoughtNumbers = this.#activeThoughtNumbers.slice(startIndex);
+        this.#recomputeActiveMaxTotalThoughts();
     }
     #removeOldest(count, options = {}) {
         const totalLength = this.getTotalLength();
@@ -147,27 +159,24 @@ export class ThoughtStore {
     #compactIfNeeded(force = false) {
         if (this.#headIndex === 0)
             return;
-        const totalLength = this.getTotalLength();
-        if (totalLength === 0) {
+        if (this.getTotalLength() === 0) {
             this.#resetThoughts();
             return;
         }
-        if (!this.#shouldCompact(force))
+        if (!force &&
+            this.#headIndex < COMPACT_THRESHOLD &&
+            this.#headIndex < this.#thoughts.length * COMPACT_RATIO) {
             return;
+        }
         this.#thoughts = this.#thoughts.slice(this.#headIndex);
         this.#headIndex = 0;
     }
-    #shouldCompact(force) {
-        if (force)
-            return true;
-        return (this.#headIndex >= COMPACT_THRESHOLD ||
-            this.#headIndex >= this.#thoughts.length * COMPACT_RATIO);
-    }
     #resetThoughts() {
         this.#thoughts = [];
         this.#thoughtIndex.clear();
         this.#activeThoughts = [];
         this.#activeThoughtNumbers = [];
+        this.#activeMaxTotalThoughts = 0;
         this.#headIndex = 0;
         this.#nextThoughtNumber = 1;
         this.#estimatedBytes = 0;

package/dist/engine.js

@@ -24,11 +24,8 @@ export class ThinkingEngine {
         return this.#processNewThought(input);
     }
     #processNewThought(input) {
-        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(input);
-        const numbers = this.#store.nextThoughtNumbers(effectiveTotalThoughts);
-        const stored = this.#buildStoredThought(input, numbers);
-        this.#store.storeThought(stored);
-        this.#store.pruneHistoryIfNeeded();
+        const { stored } = this.#createStoredThought(input);
+        this.#commitThought(stored);
         return this.#buildProcessResult(stored);
     }
     #processRevision(input) {
@@ -36,18 +33,14 @@ export class ThinkingEngine {
         if (!resolved.ok)
             return resolved.error;
         const { targetNumber } = resolved;
-        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(input);
-        const numbers = this.#store.nextThoughtNumbers(effectiveTotalThoughts);
+        const { numbers, stored } = this.#createStoredThought(input, {
+            revisionOf: targetNumber,
+        });
         const supersedesAll = this.#store.supersedeFrom(targetNumber, numbers.thoughtNumber);
         const supersedesTotal = supersedesAll.length;
         const supersedes = capArrayStart(supersedesAll, MAX_SUPERSEDES);
-        const stored = this.#buildStoredThought(input, {
-            ...numbers,
-            revisionOf: targetNumber,
-        });
-        this.#store.storeThought(stored);
         this.#hasRevisions = true;
-        this.#store.pruneHistoryIfNeeded();
+        this.#commitThought(stored);
         return this.#buildProcessResult(stored, {
             revises: targetNumber,
             supersedes,
@@ -69,14 +62,26 @@ export class ThinkingEngine {
             }),
         };
     }
+    #createStoredThought(input, extras = {}) {
+        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(input);
+        const numbers = this.#store.nextThoughtNumbers(effectiveTotalThoughts);
+        const stored = this.#buildStoredThought(input, {
+            ...numbers,
+            ...extras,
+        });
+        return { stored, numbers };
+    }
+    #commitThought(stored) {
+        this.#store.storeThought(stored);
+        this.#store.pruneHistoryIfNeeded();
+    }
     #resolveEffectiveTotalThoughts(input) {
         if (input.totalThoughts !== undefined) {
             return input.totalThoughts;
         }
         const activeThoughts = this.#store.getActiveThoughts();
         const lastActive = activeThoughts[activeThoughts.length - 1];
-        if (lastActive !== undefined &&
-            lastActive.totalThoughts > _a.DEFAULT_TOTAL_THOUGHTS) {
+        if (lastActive !== undefined) {
             return lastActive.totalThoughts;
         }
         return _a.DEFAULT_TOTAL_THOUGHTS;

package/dist/instructions.md

@@ -1,66 +1,76 @@
-# ThinkSeq MCP Server — Instructions
+# ThinkSeq MCP Server — AI Usage Instructions
 
-## What this server does
+Use this server to record sequential thinking steps to plan, reason, and debug. Prefer these tools over "remembering" state in chat.
 
-ThinkSeq exposes one MCP tool, `thinkseq`, to help you keep a short, numbered chain of reasoning steps with progress tracking and revision support.
+## Operating Rules
 
-- State is in-memory only and resets when the server restarts.
-- Keep each step concise; this is a structure/coordination tool, not a scratchpad for long text.
+- Keep thoughts atomic: one decision, calculation, or action per step.
+- Use revisions to fix mistakes in the active chain instead of apologizing in chat.
+- If request is vague, ask clarifying questions.
 
-## Available tools
+### Strategies
 
-### `thinkseq`
+- **Discovery:** Read the tool output's `context` to see recent thoughts and available revision targets.
+- **Action:** Use `thinkseq` to advance the reasoning chain or `revisesThought` to rewind and correct.
 
-Record a single sequential thinking step.
+## Data Model
 
-**Use it when:**
+- **Thinking Step:** `thought` (text), `thoughtNumber` (int), `progress` (0-1), `isComplete` (bool)
 
-- You want a small, explicit plan (step-by-step) and a progress signal.
-- You want a lightweight decision log (assumptions → choice → next action).
-- You are debugging and want a clear hypothesis → check → result chain.
+## Runtime Controls
 
-**Do not use it for:**
+- **Retention (server CLI):** the server keeps a rolling in-memory history.
+  - `--max-thoughts <number>` controls how many total stored thoughts are retained (default is 500).
+  - `--max-memory-mb <number>` caps estimated memory use for stored thoughts (default is 100MB).
+- **Text content compatibility:** by default the tool returns both `structuredContent` and a JSON string in `content`.
+  - Set `THINKSEQ_INCLUDE_TEXT_CONTENT=0|false|no|off` to omit the JSON string and return only `structuredContent`.
 
-- Long-form writing or dumping large transcripts.
-- Storing secrets, credentials, or personal data.
+## Workflows
 
-**Inputs:**
+### 1) Structured Reasoning
 
-- `thought` (string, 1–5000 chars, required): one concise step.
-- `totalThoughts` (int, 1–25, optional): estimated total steps (default: 3).
-- `revisesThought` (int ≥ 1, optional): revise a previous step by its `thoughtNumber`.
+```text
+thinkseq(thought="Plan: 1. check, 2. fix", totalThoughts=5) → Start chain
+thinkseq(thought="Check passed, starting fix") → Progress chain
+thinkseq(thought="Revised plan: use new API", revisesThought=1) → Correction
+```
 
-**Revision semantics (important):**
+Notes:
 
-- A revision is a destructive rewind of the _active chain_.
-- When you set `revisesThought`, the tool supersedes the targeted thought and every later _active_ thought, then continues from your corrected step.
-- Superseded thoughts remain in history for audit, but they are no longer in the active chain.
+- `totalThoughts` is only an estimate for progress/completion (max 25); it does **not** change retention.
+- Revisions can only target active (non-superseded) thoughts.
 
-**Outputs (prefer `structuredContent`):**
+## Tools
 
-- `result.progress` in [0, 1] and `result.isComplete`
-- `result.revisableThoughts`: thought numbers you can revise
-- `result.context.recentThoughts`: previews of the current active chain
-- `result.context.revisionInfo`: present only when a revision occurred
+### thinkseq
 
-## Recommended workflow
+Record a concise thinking step (max 5000 chars). Be brief: capture only the essential insight, calculation, or decision.
 
-1. Set `totalThoughts` once at the start (adjust later if needed).
-2. Call `thinkseq` once per step; keep `thought` focused (one decision, one calculation, or one next action).
-3. If you discover an earlier mistake, call `thinkseq` again with `revisesThought` to correct it.
-4. Stop using the tool when `isComplete` becomes `true` (or once you have enough structure to proceed).
+- **Use when:** You need to structured reasoning, planning, or a decision log.
+- **Args:**
+  - `thought` (string, required): Your current thinking step.
+  - `totalThoughts` (number, optional): Estimated total thoughts (1-25, default: 3).
+  - `revisesThought` (number, optional): Revise a previous thought by number.
+- **Returns:** `thoughtNumber`, `progress`, `isComplete`, `revisableThoughts`, `context` (history previews).
 
-## Response handling guidance
+## Response Shape
 
-- Don’t paste raw tool JSON to the user unless they ask.
-- Use the tool output to write a clean, user-facing summary and next steps.
+Success: `{ "ok": true, "result": { ... } }`
+Error: `{ "ok": false, "error": { "code": "...", "message": "..." } }`
 
-## Common errors
+### Common Errors
 
-- `E_REVISION_TARGET_NOT_FOUND`: the target thought number doesn’t exist.
-- `E_REVISION_TARGET_SUPERSEDED`: the target thought is no longer active.
-- `E_THINK`: unexpected server-side failure.
+| Code                           | Meaning                                | Resolution                                |
+| ------------------------------ | -------------------------------------- | ----------------------------------------- |
+| `E_REVISION_TARGET_NOT_FOUND`  | Revision target ID does not exist      | Check `revisableThoughts` for valid IDs   |
+| `E_REVISION_TARGET_SUPERSEDED` | Target thought was already overwritten | Revise the current active thought instead |
+| `E_THINK`                      | Generic engine error                   | Check arguments and retry                 |
 
-## Optional configuration
+## Limits
 
-- `THINKSEQ_INCLUDE_TEXT_CONTENT`: when set to `0`/`false`/`no`/`off`, the tool returns no `content` text and you should rely on `structuredContent`.
+- **Max Thoughts:** 25 (default estimate)
+- **Max Length:** 5000 chars per thought
+
+## Security
+
+- Do not store credentials, secrets, or PII in thoughts. State is in-memory only but may be logged.

package/dist/lib/cli.js

@@ -20,11 +20,24 @@ Options:
   --package-read-timeout-ms <number>  Package.json read timeout
   -h, --help                       Show this help`;
 const BYTES_PER_MB = 1024 * 1024;
+const CLI_OPTION_SPECS = [
+    { key: 'max-thoughts', configKey: 'maxThoughts' },
+    {
+        key: 'max-memory-mb',
+        configKey: 'maxMemoryBytes',
+        map: (value) => value * BYTES_PER_MB,
+    },
+    { key: 'shutdown-timeout-ms', configKey: 'shutdownTimeoutMs' },
+    { key: 'package-read-timeout-ms', configKey: 'packageReadTimeoutMs' },
+];
 function parsePositiveInt(value, label) {
     if (value === undefined)
         return undefined;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`Invalid ${label}: ${value}`);
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) {
         throw new Error(`Invalid ${label}: ${value}`);
     }
     return parsed;
@@ -40,21 +53,14 @@ function getStringOption(values, key) {
     return typeof value === 'string' ? value : undefined;
 }
 function buildCliConfig(values) {
-    const maxThoughts = parsePositiveInt(getStringOption(values, 'max-thoughts'), 'max-thoughts');
-    const maxMemoryMb = parsePositiveInt(getStringOption(values, 'max-memory-mb'), 'max-memory-mb');
-    const shutdownTimeoutMs = parsePositiveInt(getStringOption(values, 'shutdown-timeout-ms'), 'shutdown-timeout-ms');
-    const packageReadTimeoutMs = parsePositiveInt(getStringOption(values, 'package-read-timeout-ms'), 'package-read-timeout-ms');
     const config = {};
-    if (maxThoughts !== undefined)
-        config.maxThoughts = maxThoughts;
-    if (maxMemoryMb !== undefined) {
-        config.maxMemoryBytes = maxMemoryMb * BYTES_PER_MB;
-    }
-    if (shutdownTimeoutMs !== undefined) {
-        config.shutdownTimeoutMs = shutdownTimeoutMs;
-    }
-    if (packageReadTimeoutMs !== undefined) {
-        config.packageReadTimeoutMs = packageReadTimeoutMs;
+    for (const spec of CLI_OPTION_SPECS) {
+        const raw = getStringOption(values, spec.key);
+        const parsed = parsePositiveInt(raw, spec.key);
+        if (parsed === undefined)
+            continue;
+        const mapped = spec.map ? spec.map(parsed) : parsed;
+        config[spec.configKey] = mapped;
     }
     return config;
 }

package/dist/lib/package.js

@@ -2,7 +2,6 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const defaultReadFile = (path, options) => readFile(path, options);
-const defaultCwd = () => process.cwd();
 const defaultPackageJsonPath = fileURLToPath(new URL('../../package.json', import.meta.url));
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
@@ -30,25 +29,16 @@ function parsePackageJson(raw) {
         return {};
     }
 }
-function resolveReadFile(deps) {
-    return deps?.readFile ?? defaultReadFile;
-}
-function resolveCwd(deps) {
-    return deps?.cwd ?? defaultCwd;
-}
 function resolvePackageJsonPath(deps) {
     // Only honor cwd injection when readFile is also injected (test seam).
     if (deps?.readFile && deps.cwd)
-        return join(resolveCwd(deps)(), 'package.json');
+        return join(deps.cwd(), 'package.json');
     return defaultPackageJsonPath;
 }
-function buildReadOptions(signal) {
-    return signal ? { encoding: 'utf8', signal } : { encoding: 'utf8' };
-}
 export async function readSelfPackageJson(signal, deps) {
     try {
-        const readFileImpl = resolveReadFile(deps);
-        const raw = await readFileImpl(resolvePackageJsonPath(deps), buildReadOptions(signal));
+        const readFileImpl = deps?.readFile ?? defaultReadFile;
+        const raw = await readFileImpl(resolvePackageJsonPath(deps), signal ? { encoding: 'utf8', signal } : { encoding: 'utf8' });
         return parsePackageJson(raw);
     }
     catch {

package/dist/lib/protocolGuards.js

@@ -42,15 +42,16 @@ function wrapWithInitializationGuard(method, handler, state) {
         return await handler(request, extra);
     };
 }
-function getProtocolObject(server) {
+function getProtocolHandlers(server) {
     if (!isRecord(server))
         return undefined;
     const protocol = Reflect.get(server, 'server');
-    return isRecord(protocol) ? protocol : undefined;
-}
-function getRequestHandlers(protocol) {
+    if (!isRecord(protocol))
+        return undefined;
     const handlers = Reflect.get(protocol, '_requestHandlers');
-    return handlers instanceof Map ? handlers : undefined;
+    if (!(handlers instanceof Map))
+        return undefined;
+    return { protocol, handlers };
 }
 function installFallbackRequestHandler(protocol, state) {
     // Guard unknown methods as well (so pre-init calls to unknown methods don't
@@ -76,13 +77,10 @@ function wrapRequestHandlers(handlers, state) {
     }
 }
 export function installInitializationGuards(server) {
-    const protocol = getProtocolObject(server);
-    if (!protocol)
-        return;
-    const handlers = getRequestHandlers(protocol);
-    if (!handlers)
+    const resolved = getProtocolHandlers(server);
+    if (!resolved)
         return;
     const state = { sawInitialize: false };
-    wrapRequestHandlers(handlers, state);
-    installFallbackRequestHandler(protocol, state);
+    wrapRequestHandlers(resolved.handlers, state);
+    installFallbackRequestHandler(resolved.protocol, state);
 }

package/dist/lib/stdioGuards.d.ts

@@ -1,2 +1,3 @@
+export declare function installStdioInitializationGuards(transport: unknown): void;
 export declare function installStdioInvalidMessageGuards(transport: unknown): void;
 export declare function installStdioParseErrorResponder(transport: unknown): void;