context-doctor 0.3.6 → 0.4.0

package/README.md

@@ -1,5 +1,7 @@
 # context-doctor 🩺
 
+[![CI](https://github.com/KushalP1/context-doctor/actions/workflows/ci.yml/badge.svg)](https://github.com/KushalP1/context-doctor/actions) [![npm](https://img.shields.io/npm/v/context-doctor)](https://www.npmjs.com/package/context-doctor)
+
 **See what's eating your LLM context window — and fix it.**
 
 Every long-running LLM conversation slowly fills up with junk: duplicated documents, 10k-token tool outputs nobody reads again, base64 blobs, stale history. You pay for those tokens on **every single call**, and model quality drops as the window fills.
@@ -93,7 +95,8 @@ Practical upshot: a developer who only wants cheaper, faster API calls never tou
 | `context-doctor session [file]` | Profile a Claude Code session transcript (defaults to your most recent; `--list` to browse) |
 | `context-doctor report` | Machine-wide impact report: exact proxy savings, hook activity, recoverable waste in recent sessions |
 | `context-doctor proxy` | Always-on local proxy that optimizes every Anthropic/OpenAI API request in flight (`/stats` for cumulative savings) |
-| `context-doctor hook` | The every-prompt Claude Code hook (registered by `install`; you never run this yourself) |
+| `context-doctor hook` | The every-prompt Claude Code hook (registered by `install`; you never run this yourself). Warning threshold tunable via `CONTEXT_DOCTOR_WARN_TOKENS` (default 80000) |
+| `context-doctor-mcp` | The MCP server itself — stdio by default (what the installer wires); `--http [--port 8808] [--host H]` serves streamable HTTP at `/mcp` for URL-based clients like ChatGPT developer-mode connectors |
 
 ## What "always-on" means, per surface
 
@@ -175,7 +178,7 @@ Because prompt caching matches byte-identical prefixes, deterministic strategies
 | Claude Desktop | `npx context-doctor install` writes the config — just restart the app |
 | Claude Code | Same command — MCP + skill + every-prompt hook, all automatic |
 | Cursor | Same command — writes `~/.cursor/mcp.json` |
-| ChatGPT desktop | **Manual, one time** (ChatGPT's connectors live inside its own settings): Settings → Connectors → Developer mode → add local server, command `npx`, args `-y context-doctor-mcp` |
+| ChatGPT (developer mode) | **Manual + a reachable URL** — ChatGPT connects to servers over the internet, never local commands. Run `context-doctor-mcp --http` on a host/tunnel, then add the URL as a connector. Normal ChatGPT (no dev mode) has no MCP — use the CLI |
 
 For any other MCP client, the server entry is:
 
@@ -197,14 +200,15 @@ For any other MCP client, the server entry is:
 3. Chat normally. When a conversation grows heavy, Claude proactively offers: *"this chat is getting large — want me to profile it?"* — or you ask *"what's eating my context?"* and it calls `profile_context` and shows the token/cost breakdown.
 4. Say *"optimize it"* and Claude applies the safe fixes; if you agree to pruning old history, **Claude itself writes the replacement summary** (that's the no-API-key summarization).
 
-### How it works in ChatGPT, step by step
+### How it works in ChatGPT, step by step (honest version)
+
+ChatGPT's MCP support differs fundamentally from Claude Desktop's: **it never spawns local processes**. Its custom connectors (developer mode) have OpenAI's servers connect to a **URL** — so the MCP server must be reachable from the internet.
 
-1. ChatGPT's desktop app supports MCP in **developer mode**: Settings → Connectors → Advanced → Developer mode, then add a local MCP server with command `npx` and args `-y context-doctor-mcp`.
-2. Enable the connector in a chat. GPT sees the same three tools with the same trigger guidance baked into their descriptions.
-3. Ask *"profile this conversation"* or paste an exported chat and ask *"what's eating my context?"* — GPT calls `profile_context` and reports the breakdown; *"optimize it"* works the same, including GPT writing the pruning summary itself.
-4. Caveat: how prominently standing server instructions surface varies by ChatGPT version — the tool descriptions carry the trigger rules regardless, so profiling still fires on the right questions.
+1. **Normal ChatGPT (no developer mode): no MCP at all.** context-doctor still helps via the CLI: export the conversation and run `npx context-doctor analyze chat.json --model gpt-5` / `optimize` — no account settings required.
+2. **ChatGPT developer mode**: run our HTTP transport somewhere reachable — `context-doctor-mcp --http --port 8808` on a small host (bind `--host 0.0.0.0` there), or expose your machine temporarily with a tunnel (`ngrok http 8808`). Then Settings → Connectors → Advanced → Developer mode → add connector with URL `https://<your-host>/mcp`.
+3. Once connected, GPT gets the same three tools with the same trigger guidance: ask *"what's eating my context?"* → it calls `profile_context`; *"optimize it"* works the same, including GPT writing the pruning summary itself.
 
-For ChatGPT on the web (no MCP): export the conversation and use the CLI — `npx context-doctor analyze chat.json --model gpt-5`.
+Security note for step 2: the HTTP endpoint is unauthenticated — put it behind your tunnel's auth or a reverse proxy if it stays up long-term.
 
 ### claude.ai on the web
 

package/dist/hook.js

@@ -17,8 +17,8 @@ import { profileConversation } from "./profile.js";
 import { parseSessionFile } from "./session.js";
 import { formatTokens } from "./tokens.js";
 import { formatUsd } from "./pricing.js";
-/** Start nudging at 80k tokens of context. */
-const WARN_TOKENS = 80_000;
+/** Start nudging at 80k tokens of context (override: CONTEXT_DOCTOR_WARN_TOKENS). */
+const WARN_TOKENS = Number(process.env.CONTEXT_DOCTOR_WARN_TOKENS) > 0 ? Number(process.env.CONTEXT_DOCTOR_WARN_TOKENS) : 80_000;
 /** Re-nudge only after the context grows another 40% — one reminder, not a nag. */
 const REGROWTH_FACTOR = 1.4;
 /**

package/dist/install.js

@@ -167,5 +167,13 @@ export function runUninstall() {
         console.log("✓ Agent Skill removed");
     }
     uninstallHook();
+    // Remove our bookkeeping files too — uninstall means gone.
+    for (const file of [".context-doctor-hook-state.json", ".context-doctor-ledger.jsonl"]) {
+        const p = join(homedir(), ".claude", file);
+        if (existsSync(p)) {
+            rmSync(p);
+            console.log(`✓ Removed ${file}`);
+        }
+    }
     console.log("Done.");
 }

package/dist/ledger.js

@@ -8,7 +8,7 @@
  *              (pre-0.3.6 hook entries have no `ev` field; treated as checks)
  *   optimize — an optimization was applied  {ev: "optimize", src: "cli"|"mcp", saved, model?}
  */
-import { appendFileSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 export function statePath() {
@@ -20,6 +20,9 @@ export function ledgerPath() {
 export function recordLedger(entry) {
     const path = ledgerPath();
     try {
+        // Claude-Desktop-only machines have no ~/.claude — create it so their
+        // optimize events count in `context-doctor report` too.
+        mkdirSync(dirname(path), { recursive: true });
         // Cap growth: past ~256KB keep the most recent 500 entries.
         if (existsSync(path) && statSync(path).size > 256 * 1024) {
             const lines = readFileSync(path, "utf8").trimEnd().split("\n");

package/dist/mcp.js

@@ -30,63 +30,77 @@ import { recordLedger } from "./ledger.js";
 // Kept deliberately terse: these ride in EVERY conversation's context, and a
 // context-saving tool must not itself be context overhead (~110 tokens).
 const SERVER_INSTRUCTIONS = `Context hygiene, always: summarize large pastes/tool results instead of carrying them verbatim; reference earlier content, don't re-quote; never inline base64. Past ~30 turns or several large pastes, proactively offer to run profile_context. Any question about tokens, cost, or latency: call profile_context, don't estimate. If optimize_context returns a pruned-turns digest, you write the ≤150-token replacement summary.`;
-const server = new McpServer({ name: "context-doctor", version: "0.3.6" }, { instructions: SERVER_INSTRUCTIONS });
 const STRATEGY_IDS = ["dedupe", "trim-tool-results", "strip-base64", "prune-history"];
-server.tool("profile_context", "Profile an LLM conversation or prompt: token breakdown by category, largest messages, and actionable findings about wasted context (duplicates, oversized tool results, base64 blobs, cache-unfriendly ordering). Accepts OpenAI/Anthropic conversation JSON or raw text. Call this immediately whenever the user asks about token usage, context size, LLM cost, or latency — and proactively offer it once a conversation grows long or accumulates large pasted content.", {
-    conversation: z.string().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array) or raw prompt text"),
-    model: z.string().optional().describe("Target model name for context-window math, e.g. claude-sonnet-5 or gpt-4o"),
-}, async ({ conversation, model }) => {
-    const profile = profileConversation(parseConversation(conversation), model);
-    return { content: [{ type: "text", text: renderProfile(profile) }] };
-});
-server.tool("optimize_context", "Rewrite a conversation to reclaim tokens using deterministic strategies: dedupe repeated content, trim stale tool results, strip base64 blobs, optionally prune old history. Returns the slimmed conversation JSON plus a savings summary. No LLM calls — safe and inspectable. Call this after profile_context finds recoverable waste and the user wants it fixed; add the prune-history strategy only with the user's consent, then write the replacement summary yourself as the result instructs.", {
-    conversation: z.string().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array)"),
-    strategies: z.array(z.enum(STRATEGY_IDS)).optional()
-        .describe("Strategies to apply. Default: dedupe, trim-tool-results, strip-base64. Add prune-history for lossy compaction of old turns."),
-    keep_recent: z.number().int().positive().optional().describe("Messages at the tail to leave untouched (default 6)"),
-    max_tool_result_tokens: z.number().int().positive().optional().describe("Token budget for trimmed tool results (default 300)"),
-}, async ({ conversation, strategies, keep_recent, max_tool_result_tokens }) => {
-    const result = optimizeConversation(conversation, {
-        strategies: strategies,
-        keepRecent: keep_recent,
-        maxToolResultTokens: max_tool_result_tokens,
+/**
+ * Build a fully-configured server instance. A factory (not a singleton) so the
+ * stateless HTTP mode can hand every request its own server, per the MCP SDK's
+ * recommended pattern.
+ */
+function createServer() {
+    const server = new McpServer({ name: "context-doctor", version: "0.4.0" }, { instructions: SERVER_INSTRUCTIONS });
+    server.tool("profile_context", "Profile an LLM conversation or prompt: token breakdown by category, largest messages, and actionable findings about wasted context (duplicates, oversized tool results, base64 blobs, cache-unfriendly ordering). Accepts OpenAI/Anthropic conversation JSON or raw text. Call this immediately whenever the user asks about token usage, context size, LLM cost, or latency — and proactively offer it once a conversation grows long or accumulates large pasted content.", {
+        conversation: z.string().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array) or raw prompt text"),
+        model: z.string().optional().describe("Target model name for context-window math, e.g. claude-sonnet-5 or gpt-4o"),
+    }, async ({ conversation, model }) => {
+        const profile = profileConversation(parseConversation(conversation), model);
+        return { content: [{ type: "text", text: renderProfile(profile) }] };
     });
-    const saved = result.tokensBefore - result.tokensAfter;
-    if (saved > 0) {
-        recordLedger({ ev: "optimize", src: "mcp", saved, model: result.conversation?.model });
-    }
-    const summary = `Saved ~${formatTokens(saved)} tokens (${formatTokens(result.tokensBefore)} → ${formatTokens(result.tokensAfter)}) ` +
-        `via ${result.applied.length} change(s):\n` +
-        result.applied.map((c) => `- [${c.strategy}] message #${c.messageIndex}: ${c.note} (~${formatTokens(c.tokensSaved)})`).join("\n");
-    // Echoing a huge optimized conversation back inline would flood the very
-    // context this tool exists to save. Above the cap, return the summary and
-    // point at the CLI (compact JSON keeps mid-size results affordable).
-    const ECHO_CAP_CHARS = 100_000;
-    const conversationJson = JSON.stringify(result.conversation);
-    const content = [
-        { type: "text", text: summary },
-        conversationJson.length <= ECHO_CAP_CHARS
-            ? { type: "text", text: conversationJson }
-            : {
-                type: "text",
-                text: `[optimized conversation is ${conversationJson.length} chars — too large to echo into this context. ` +
-                    `Tell the user the savings above and that \`npx context-doctor optimize <file> --out slim.json\` produces the file directly.]`,
-            },
-    ];
-    // Host-model summarization: instead of calling an LLM ourselves (which would
-    // need an API key), hand the pruned material to the model that invoked this
-    // tool and ask IT to write the summary.
-    if (result.prunedDigest) {
-        content.push({
-            type: "text",
-            text: "ACTION REQUIRED (you, the assistant calling this tool): the pruned turns are digested below. " +
-                "Write a dense factual summary of them (≤150 tokens: decisions, current state, open items, key identifiers) " +
-                "and replace the '[context-doctor: ... pruned]' stub message in the conversation above with your summary " +
-                "before presenting the result.\n\nPRUNED TURNS DIGEST:\n" + result.prunedDigest,
+    server.tool("optimize_context", "Rewrite a conversation to reclaim tokens using deterministic strategies: dedupe repeated content, trim stale tool results, strip base64 blobs, optionally prune old history. Returns the slimmed conversation JSON plus a savings summary. No LLM calls — safe and inspectable. Call this after profile_context finds recoverable waste and the user wants it fixed; add the prune-history strategy only with the user's consent, then write the replacement summary yourself as the result instructs.", {
+        conversation: z.string().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array)"),
+        strategies: z.array(z.enum(STRATEGY_IDS)).optional()
+            .describe("Strategies to apply. Default: dedupe, trim-tool-results, strip-base64. Add prune-history for lossy compaction of old turns."),
+        keep_recent: z.number().int().positive().optional().describe("Messages at the tail to leave untouched (default 6)"),
+        max_tool_result_tokens: z.number().int().positive().optional().describe("Token budget for trimmed tool results (default 300)"),
+    }, async ({ conversation, strategies, keep_recent, max_tool_result_tokens }) => {
+        const result = optimizeConversation(conversation, {
+            strategies: strategies,
+            keepRecent: keep_recent,
+            maxToolResultTokens: max_tool_result_tokens,
         });
-    }
-    return { content };
-});
+        const saved = result.tokensBefore - result.tokensAfter;
+        if (saved > 0) {
+            recordLedger({ ev: "optimize", src: "mcp", saved, model: result.conversation?.model });
+        }
+        const summary = `Saved ~${formatTokens(saved)} tokens (${formatTokens(result.tokensBefore)} → ${formatTokens(result.tokensAfter)}) ` +
+            `via ${result.applied.length} change(s):\n` +
+            result.applied.map((c) => `- [${c.strategy}] message #${c.messageIndex}: ${c.note} (~${formatTokens(c.tokensSaved)})`).join("\n");
+        // Echoing a huge optimized conversation back inline would flood the very
+        // context this tool exists to save. Above the cap, return the summary and
+        // point at the CLI (compact JSON keeps mid-size results affordable).
+        const ECHO_CAP_CHARS = 100_000;
+        const conversationJson = JSON.stringify(result.conversation);
+        const content = [
+            { type: "text", text: summary },
+            conversationJson.length <= ECHO_CAP_CHARS
+                ? { type: "text", text: conversationJson }
+                : {
+                    type: "text",
+                    text: `[optimized conversation is ${conversationJson.length} chars — too large to echo into this context. ` +
+                        `Tell the user the savings above and that \`npx context-doctor optimize <file> --out slim.json\` produces the file directly.]`,
+                },
+        ];
+        // Host-model summarization: instead of calling an LLM ourselves (which would
+        // need an API key), hand the pruned material to the model that invoked this
+        // tool and ask IT to write the summary.
+        if (result.prunedDigest) {
+            content.push({
+                type: "text",
+                text: "ACTION REQUIRED (you, the assistant calling this tool): the pruned turns are digested below. " +
+                    "Write a dense factual summary of them (≤150 tokens: decisions, current state, open items, key identifiers) " +
+                    "and replace the '[context-doctor: ... pruned]' stub message in the conversation above with your summary " +
+                    "before presenting the result.\n\nPRUNED TURNS DIGEST:\n" + result.prunedDigest,
+            });
+        }
+        return { content };
+    });
+    server.tool("context_best_practices", "Get a curated checklist of context-management best practices, optionally specialized for a provider (anthropic, openai).", {
+        provider: z.enum(["general", "anthropic", "openai"]).optional().describe("Provider to specialize tips for (default: general)"),
+    }, async ({ provider }) => {
+        const tips = [...BEST_PRACTICES.general, ...(provider && provider !== "general" ? BEST_PRACTICES[provider] : [])];
+        return { content: [{ type: "text", text: tips.map((t, i) => `${i + 1}. ${t}`).join("\n") }] };
+    });
+    return server;
+}
 const BEST_PRACTICES = {
     general: [
         "Put stable content first (system prompt, tool definitions, reference docs) and volatile content last — prompt caches match byte-identical prefixes only.",
@@ -106,11 +120,61 @@ const BEST_PRACTICES = {
         "Use max_completion_tokens headroom math: input + output must fit the window together.",
     ],
 };
-server.tool("context_best_practices", "Get a curated checklist of context-management best practices, optionally specialized for a provider (anthropic, openai).", {
-    provider: z.enum(["general", "anthropic", "openai"]).optional().describe("Provider to specialize tips for (default: general)"),
-}, async ({ provider }) => {
-    const tips = [...BEST_PRACTICES.general, ...(provider && provider !== "general" ? BEST_PRACTICES[provider] : [])];
-    return { content: [{ type: "text", text: tips.map((t, i) => `${i + 1}. ${t}`).join("\n") }] };
-});
-const transport = new StdioServerTransport();
-await server.connect(transport);
+// -- Transport dispatch --------------------------------------------------------
+// Default: stdio (Claude Desktop, Claude Code, Cursor spawn us as a child).
+// --http [--port N] [--host H]: streamable-HTTP endpoint at /mcp for clients
+// that connect to a URL instead of spawning a process — ChatGPT developer-mode
+// connectors (which require a reachable URL), web MCP clients, remote setups.
+const argv = process.argv.slice(2);
+if (argv.includes("--http")) {
+    const argAfter = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 ? argv[i + 1] : undefined;
+    };
+    const port = Number(argAfter("--port")) > 0 ? Number(argAfter("--port")) : 8808;
+    const host = argAfter("--host") ?? "127.0.0.1";
+    const { createServer: createHttpServer } = await import("node:http");
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    createHttpServer(async (req, res) => {
+        try {
+            if (req.url === "/health") {
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ ok: true, service: "context-doctor-mcp" }));
+                return;
+            }
+            if (!(req.url ?? "").startsWith("/mcp")) {
+                res.statusCode = 404;
+                res.end(JSON.stringify({ error: "MCP endpoint is /mcp" }));
+                return;
+            }
+            if (req.method !== "POST") {
+                // Stateless mode: no standalone SSE stream, no sessions to delete.
+                res.statusCode = 405;
+                res.setHeader("allow", "POST");
+                res.end(JSON.stringify({ error: "Stateless server: POST /mcp only" }));
+                return;
+            }
+            // Fresh server + transport per request (stateless — nothing shared).
+            const server = createServer();
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            res.on("close", () => {
+                void transport.close();
+                void server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res);
+        }
+        catch (e) {
+            if (!res.headersSent)
+                res.statusCode = 500;
+            res.end(JSON.stringify({ error: e.message }));
+        }
+    }).listen(port, host, () => {
+        console.error(`context-doctor MCP (streamable HTTP) on http://${host}:${port}/mcp`);
+        console.error(`ChatGPT developer-mode connectors need a URL their servers can reach — expose this via your host or a tunnel.`);
+    });
+}
+else {
+    const transport = new StdioServerTransport();
+    await createServer().connect(transport);
+}

package/dist/test/mcp-http.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP streamable-HTTP transport: spawn `mcp.js --http`, run the initialize
+ * handshake and a tool call over plain HTTP, exactly as a URL-based client
+ * (e.g. a ChatGPT developer-mode connector) would.
+ */
+export {};

package/dist/test/mcp-http.test.js

@@ -0,0 +1,63 @@
+/**
+ * MCP streamable-HTTP transport: spawn `mcp.js --http`, run the initialize
+ * handshake and a tool call over plain HTTP, exactly as a URL-based client
+ * (e.g. a ChatGPT developer-mode connector) would.
+ */
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const mcpPath = join(dirname(fileURLToPath(import.meta.url)), "..", "mcp.js");
+const PORT = 8898;
+const child = spawn(process.execPath, [mcpPath, "--http", "--port", String(PORT)], { stdio: ["ignore", "ignore", "pipe"] });
+await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("HTTP MCP server did not start")), 8000);
+    child.stderr.on("data", (d) => {
+        if (d.toString().includes("streamable HTTP")) {
+            clearTimeout(timer);
+            resolve();
+        }
+    });
+});
+after(() => child.kill());
+async function rpc(body) {
+    const res = await fetch(`http://127.0.0.1:${PORT}/mcp`, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    // Streamable HTTP may answer as SSE ("data: {...}") or plain JSON.
+    const dataLine = text.split("\n").find((l) => l.startsWith("data: "));
+    return { status: res.status, json: JSON.parse(dataLine ? dataLine.slice(6) : text) };
+}
+test("initialize over HTTP returns server info + instructions", async () => {
+    const { status, json } = await rpc({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "t", version: "1" } },
+    });
+    assert.equal(status, 200);
+    assert.equal(json.result.serverInfo.name, "context-doctor");
+    assert.ok(json.result.instructions.includes("Context hygiene"));
+});
+test("tools/call works statelessly over HTTP", async () => {
+    const { json } = await rpc({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "profile_context",
+            arguments: { conversation: JSON.stringify({ messages: [{ role: "user", content: "hello world" }] }) },
+        },
+    });
+    assert.ok(json.result.content[0].text.includes("CONTEXT DOCTOR"));
+});
+test("health endpoint responds; non-POST is rejected", async () => {
+    const health = (await (await fetch(`http://127.0.0.1:${PORT}/health`)).json());
+    assert.equal(health.ok, true);
+    const get = await fetch(`http://127.0.0.1:${PORT}/mcp`);
+    assert.equal(get.status, 405);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-doctor",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Profile and optimize LLM context windows. See what's eating your tokens and fix it — works with Claude, GPT, Gemini, and any MCP-capable AI app.",
   "keywords": [
     "llm",
@@ -41,7 +41,7 @@
     "build": "tsc && node -e \"const fs=require('fs');['dist/cli.js','dist/mcp.js'].forEach(f=>fs.chmodSync(f,0o755))\"",
     "prepublishOnly": "npm run build",
     "dev": "tsc --watch",
-    "test": "npm run build && node --test dist/test/smoke.test.js dist/test/proxy.test.js dist/test/hook.test.js"
+    "test": "npm run build && node --test dist/test/smoke.test.js dist/test/proxy.test.js dist/test/hook.test.js dist/test/mcp-http.test.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",