@konseki/mcp 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,135 @@
+# Konseki MCP
+
+Official Model Context Protocol server for Konseki.
+
+Konseki MCP is a direct wrapper around the Konseki public API. It lets AI agents and AI trading tools call Konseki endpoints through MCP tools while preserving the raw API response JSON for the user or downstream application to interpret.
+
+## Requirements
+
+- Node.js 20 or newer.
+- A Konseki API key.
+
+## Design Principles
+
+- Direct API wrapper: the MCP server fetches Konseki API responses and returns them without interpretation.
+- User-owned interpretation: users, builders, and downstream AI clients decide how to analyze or summarize the returned JSON.
+- Public API only: the server uses `X-API-Key` against documented Konseki endpoints.
+- No internal credentials: non-public service or operational credentials are never required for this package.
+
+## Configuration
+
+The server reads configuration from environment variables:
+
+```sh
+KONSEKI_API_KEY=ks_live_your_api_key
+```
+
+Do not commit real API keys.
+
+## Intended Architecture
+
+```text
+AI client
+  |
+  v
+Konseki MCP server
+  |
+  v
+Konseki public API
+  |
+  v
+Raw historical market context JSON
+```
+
+The MCP server should not bypass Konseki public API behavior. It should behave like any other public API client.
+
+## Tools
+
+### `get_konseki_metadata`
+
+Fetches raw JSON from `GET /v1/metadata`.
+
+Input: none.
+
+### `list_konseki_symbols`
+
+Fetches raw JSON from `GET /v1/symbols`.
+
+Input: none.
+
+### `get_konseki_analysis`
+
+Fetches raw JSON from `GET /v1/analysis/{symbol}-{exchange}?lookback={lookback}`.
+
+Input:
+
+```json
+{
+  "symbol": "AAPL",
+  "exchange": "NASDAQ",
+  "lookback": 15
+}
+```
+
+Supported `lookback` values: `5`, `10`, `15`, `20`, `25`, `30`, `40`, `50`.
+
+## Response Compression
+
+The server requests gzip-compressed API responses and decompresses them locally before returning JSON to the MCP client. This is handled automatically; users do not need to configure compression.
+
+## Installation
+
+Use the package through an MCP client with `npx`:
+
+```json
+{
+  "mcpServers": {
+    "konseki": {
+      "command": "npx",
+      "args": ["-y", "@konseki/mcp"],
+      "env": {
+        "KONSEKI_API_KEY": "ks_live_your_api_key"
+      }
+    }
+  }
+}
+```
+
+For local development from this checkout, configure your MCP client to run the built server:
+
+```json
+{
+  "mcpServers": {
+    "konseki": {
+      "command": "node",
+      "args": ["/absolute/path/to/konseki-mcp/dist/index.js"],
+      "env": {
+        "KONSEKI_API_KEY": "ks_live_your_api_key"
+      }
+    }
+  }
+}
+```
+
+## Development
+
+Install dependencies:
+
+```sh
+npm install
+```
+
+Run verification:
+
+```sh
+npm run typecheck
+npm test
+npm run build
+```
+
+## Security
+
+- Never commit real API keys.
+- Never log raw API keys.
+- Never include user credentials in test snapshots or examples.
+- Use fake keys in documentation and tests.

package/SECURITY.md

@@ -0,0 +1,14 @@
+# Security
+
+## Reporting Vulnerabilities
+
+Please report suspected security vulnerabilities privately through the repository's GitHub security advisory flow when available.
+
+Do not include real API keys, customer data, or other secrets in public issues, pull requests, tests, or examples.
+
+## Secret Handling
+
+- Configure the server with `KONSEKI_API_KEY` in your local MCP client environment.
+- Do not commit real API keys.
+- Do not paste real API keys into bug reports or screenshots.
+- Use fake keys in tests and documentation.

package/dist/client.d.ts

@@ -0,0 +1,33 @@
+import { type KonsekiMcpConfig } from "./config.js";
+export type ApiJsonObject = Record<string, unknown>;
+export type KonsekiApiResult = {
+    json: ApiJsonObject;
+    ok: true;
+    status: number;
+} | {
+    json?: ApiJsonObject;
+    message: string;
+    ok: false;
+    status?: number;
+};
+type FetchLike = typeof fetch;
+export type KonsekiApiClientOptions = {
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+};
+export declare class KonsekiApiClient {
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    constructor(config: KonsekiMcpConfig, options?: KonsekiApiClientOptions);
+    getMetadata(): Promise<KonsekiApiResult>;
+    listSymbols(): Promise<KonsekiApiResult>;
+    getAnalysis(params: {
+        exchange: string;
+        lookback: string;
+        symbol: string;
+    }): Promise<KonsekiApiResult>;
+    private request;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkD,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpG,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAIpD,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEN,KAAK,SAAS,GAAG,OAAO,KAAK,CAAC;AAE9B,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,MAAM,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,uBAAuB;IAMjE,WAAW,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAIxC,WAAW,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAIxC,WAAW,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;YAS9F,OAAO;CAsDtB"}

package/dist/client.js

@@ -0,0 +1,108 @@
+import { gunzip } from "node:zlib";
+import { promisify } from "node:util";
+import { KONSEKI_API_ORIGIN, KONSEKI_REQUEST_TIMEOUT_MS } from "./config.js";
+const gunzipAsync = promisify(gunzip);
+export class KonsekiApiClient {
+    apiKey;
+    fetchImpl;
+    timeoutMs;
+    constructor(config, options) {
+        this.apiKey = config.apiKey;
+        this.fetchImpl = options?.fetchImpl ?? fetch;
+        this.timeoutMs = options?.timeoutMs ?? KONSEKI_REQUEST_TIMEOUT_MS;
+    }
+    async getMetadata() {
+        return this.request("/v1/metadata");
+    }
+    async listSymbols() {
+        return this.request("/v1/symbols");
+    }
+    async getAnalysis(params) {
+        const symbolExchange = `${encodeURIComponent(params.symbol)}-${encodeURIComponent(params.exchange)}`;
+        const searchParams = new URLSearchParams({
+            lookback: params.lookback,
+        });
+        return this.request(`/v1/analysis/${symbolExchange}?${searchParams.toString()}`);
+    }
+    async request(pathAndQuery) {
+        const url = new URL(pathAndQuery, KONSEKI_API_ORIGIN);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(url, {
+                headers: {
+                    Accept: "application/json",
+                    "Accept-Encoding": "gzip",
+                    "X-API-Key": this.apiKey,
+                },
+                method: "GET",
+                signal: controller.signal,
+            });
+            const parsed = await parseJsonObject(response);
+            if (!parsed.ok) {
+                return {
+                    message: parsed.message,
+                    ok: false,
+                    status: response.status,
+                };
+            }
+            if (!response.ok) {
+                return {
+                    json: parsed.json,
+                    message: `Konseki API returned HTTP ${response.status}.`,
+                    ok: false,
+                    status: response.status,
+                };
+            }
+            return {
+                json: parsed.json,
+                ok: true,
+                status: response.status,
+            };
+        }
+        catch (error) {
+            const message = error instanceof DOMException && error.name === "AbortError"
+                ? "Konseki API request timed out."
+                : "Unable to reach Konseki API.";
+            return {
+                message,
+                ok: false,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function parseJsonObject(response) {
+    try {
+        const json = JSON.parse(await responseBodyText(response));
+        if (!isJsonObject(json)) {
+            return {
+                message: "Konseki API returned JSON that is not an object.",
+                ok: false,
+            };
+        }
+        return {
+            json,
+            ok: true,
+        };
+    }
+    catch {
+        return {
+            message: "Konseki API returned a non-JSON response.",
+            ok: false,
+        };
+    }
+}
+async function responseBodyText(response) {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const decompressed = isGzip(bytes) ? await gunzipAsync(bytes) : bytes;
+    return new TextDecoder().decode(decompressed);
+}
+function isGzip(bytes) {
+    return bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export type KonsekiMcpConfig = {
+    apiKey: string;
+};
+export declare const KONSEKI_API_ORIGIN = "https://api.konseki.io";
+export declare const KONSEKI_REQUEST_TIMEOUT_MS = 30000;
+export declare function loadConfigFromEnv(env?: Record<string, string | undefined>): KonsekiMcpConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAC3D,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,gBAAgB,CAUzG"}

package/dist/config.js

@@ -0,0 +1,11 @@
+export const KONSEKI_API_ORIGIN = "https://api.konseki.io";
+export const KONSEKI_REQUEST_TIMEOUT_MS = 30_000;
+export function loadConfigFromEnv(env = process.env) {
+    const apiKey = env.KONSEKI_API_KEY?.trim();
+    if (!apiKey) {
+        throw new Error("KONSEKI_API_KEY is required.");
+    }
+    return {
+        apiKey,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export { KonsekiApiClient } from "./client.js";
+export { KONSEKI_API_ORIGIN, KONSEKI_REQUEST_TIMEOUT_MS, loadConfigFromEnv, type KonsekiMcpConfig } from "./config.js";
+export { createKonsekiMcpServer } from "./server.js";
+export { normalizeAnalysisInput } from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAOA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACvH,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { pathToFileURL } from "node:url";
+import { KonsekiApiClient } from "./client.js";
+import { loadConfigFromEnv } from "./config.js";
+import { createKonsekiMcpServer } from "./server.js";
+export { KonsekiApiClient } from "./client.js";
+export { KONSEKI_API_ORIGIN, KONSEKI_REQUEST_TIMEOUT_MS, loadConfigFromEnv } from "./config.js";
+export { createKonsekiMcpServer } from "./server.js";
+export { normalizeAnalysisInput } from "./tools.js";
+async function main() {
+    const config = loadConfigFromEnv();
+    const client = new KonsekiApiClient(config);
+    const server = createKonsekiMcpServer(client);
+    await server.connect(new StdioServerTransport());
+}
+if (isCliEntryPoint()) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : "Unable to start Konseki MCP server.";
+        console.error(message);
+        process.exit(1);
+    });
+}
+function isCliEntryPoint() {
+    const entrypoint = process.argv[1];
+    return entrypoint ? import.meta.url === pathToFileURL(entrypoint).href : false;
+}

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { KonsekiApiClient } from "./client.js";
+export declare function createKonsekiMcpServer(client: KonsekiApiClient): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAQpD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAmC1E"}

package/dist/server.js

@@ -0,0 +1,22 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { analysisInputSchema, createAnalysisToolHandler, createMetadataToolHandler, createSymbolsToolHandler, } from "./tools.js";
+export function createKonsekiMcpServer(client) {
+    const server = new McpServer({
+        name: "konseki-mcp",
+        version: "1.0.0",
+    });
+    server.registerTool("get_konseki_metadata", {
+        description: "Fetch raw metadata JSON from the Konseki public API.",
+        title: "Get Konseki Metadata",
+    }, createMetadataToolHandler(client));
+    server.registerTool("list_konseki_symbols", {
+        description: "Fetch raw supported symbols JSON from the Konseki public API.",
+        title: "List Konseki Symbols",
+    }, createSymbolsToolHandler(client));
+    server.registerTool("get_konseki_analysis", {
+        description: "Fetch raw analysis JSON for a symbol, exchange, and lookback from the Konseki public API.",
+        inputSchema: analysisInputSchema,
+        title: "Get Konseki Analysis",
+    }, createAnalysisToolHandler(client));
+    return server;
+}

package/dist/tools.d.ts

@@ -0,0 +1,25 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import type { ApiJsonObject, KonsekiApiClient, KonsekiApiResult } from "./client.js";
+export declare const analysisInputSchema: {
+    exchange: z.ZodString;
+    lookback: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    symbol: z.ZodString;
+};
+export type AnalysisInput = {
+    exchange: string;
+    lookback: number | string;
+    symbol: string;
+};
+export declare function normalizeAnalysisInput(input: AnalysisInput): {
+    exchange: string;
+    lookback: string;
+    symbol: string;
+};
+export declare function jsonToolResult(json: ApiJsonObject): CallToolResult;
+export declare function apiResultToToolResult(result: KonsekiApiResult): CallToolResult;
+export declare function safeErrorResult(message: string): CallToolResult;
+export declare function createMetadataToolHandler(client: KonsekiApiClient): () => Promise<CallToolResult>;
+export declare function createSymbolsToolHandler(client: KonsekiApiClient): () => Promise<CallToolResult>;
+export declare function createAnalysisToolHandler(client: KonsekiApiClient): (input: AnalysisInput) => Promise<CallToolResult>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIrF,eAAO,MAAM,mBAAmB;;;;CAI/B,CAAC;AAIF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAYnH;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,CAUlE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAa9E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAU/D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,CAEjG;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,CAEhG;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,cAAc,CAAC,CAiBrH"}

package/dist/tools.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+const supportedLookbacks = new Set(["5", "10", "15", "20", "25", "30", "40", "50"]);
+export const analysisInputSchema = {
+    exchange: z.string().trim().min(1).regex(/^[A-Za-z]+$/, "exchange must contain only letters"),
+    lookback: z.union([z.string(), z.number()]),
+    symbol: z.string().trim().min(1).regex(/^[A-Za-z0-9.]+$/, "symbol must contain only letters, numbers, and dots"),
+};
+const analysisInputObjectSchema = z.object(analysisInputSchema);
+export function normalizeAnalysisInput(input) {
+    const lookback = String(input.lookback).trim();
+    if (!supportedLookbacks.has(lookback)) {
+        throw new Error("Unsupported lookback value.");
+    }
+    return {
+        exchange: input.exchange.trim().toUpperCase(),
+        lookback,
+        symbol: input.symbol.trim().toUpperCase(),
+    };
+}
+export function jsonToolResult(json) {
+    return {
+        content: [
+            {
+                text: JSON.stringify(json, null, 2),
+                type: "text",
+            },
+        ],
+        structuredContent: json,
+    };
+}
+export function apiResultToToolResult(result) {
+    if (result.ok) {
+        return jsonToolResult(result.json);
+    }
+    if (result.json) {
+        return {
+            ...jsonToolResult(result.json),
+            isError: true,
+        };
+    }
+    return safeErrorResult(result.message);
+}
+export function safeErrorResult(message) {
+    return {
+        content: [
+            {
+                text: message,
+                type: "text",
+            },
+        ],
+        isError: true,
+    };
+}
+export function createMetadataToolHandler(client) {
+    return async () => apiResultToToolResult(await client.getMetadata());
+}
+export function createSymbolsToolHandler(client) {
+    return async () => apiResultToToolResult(await client.listSymbols());
+}
+export function createAnalysisToolHandler(client) {
+    return async (input) => {
+        try {
+            const normalizedInput = normalizeAnalysisInput(analysisInputObjectSchema.parse(input));
+            return apiResultToToolResult(await client.getAnalysis(normalizedInput));
+        }
+        catch (error) {
+            const message = error instanceof z.ZodError
+                ? "Invalid analysis request."
+                : error instanceof Error
+                    ? error.message
+                    : "Invalid analysis request.";
+            return safeErrorResult(message);
+        }
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@konseki/mcp",
+  "version": "1.0.0",
+  "description": "Official Konseki MCP server: a direct AI-agent wrapper around the Konseki public API for historical market context.",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "konseki-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "SECURITY.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run",
+    "lint": "npm run typecheck",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "keywords": [
+    "konseki",
+    "mcp",
+    "model-context-protocol",
+    "trading",
+    "market-data",
+    "historical-context"
+  ],
+  "author": "Konseki",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}