@blaxel/telemetry 0.2.0-dev1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Beamlit, Inc
+
+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/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { originalLogger } from "./logger";
+import { blaxelTelemetry } from "./telemetry";
+export { blaxelTelemetry, originalLogger };

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.originalLogger = exports.blaxelTelemetry = void 0;
+const logger_1 = require("./logger");
+Object.defineProperty(exports, "originalLogger", { enumerable: true, get: function () { return logger_1.originalLogger; } });
+const telemetry_1 = require("./telemetry");
+Object.defineProperty(exports, "blaxelTelemetry", { enumerable: true, get: function () { return telemetry_1.blaxelTelemetry; } });
+telemetry_1.blaxelTelemetry.initialize();

package/dist/instrumentationMap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/instrumentationMap.js

@@ -0,0 +1,88 @@
+"use strict";
+// export type InstrumentationInfo = {
+//   modulePath: string;
+//   className: string;
+//   requiredPackages: string[]; // At least one package is required
+//   ignoreIfPackages?: string[];
+//   init?: (instrumentor: any) => void;
+// };
+Object.defineProperty(exports, "__esModule", { value: true });
+// export const instrumentationMap: Record<string, InstrumentationInfo> = {
+//   express: {
+//     modulePath: "@opentelemetry/instrumentation-express",
+//     className: "ExpressInstrumentation",
+//     requiredPackages: ["express"],
+//     ignoreIfPackages: ["fastify"],
+//   },
+//   fastify: {
+//     modulePath: "@opentelemetry/instrumentation-fastify",
+//     className: "FastifyInstrumentation",
+//     requiredPackages: ["fastify"],
+//   },
+//   anthropic: {
+//     modulePath: "@traceloop/instrumentation-anthropic",
+//     className: "AnthropicInstrumentation",
+//     requiredPackages: ["anthropic-ai/sdk"],
+//   },
+//   azure: {
+//     modulePath: "@traceloop/instrumentation-azure",
+//     className: "AzureInstrumentation",
+//     requiredPackages: ["azure/openai"],
+//   },
+//   bedrock: {
+//     modulePath: "@traceloop/instrumentation-bedrock",
+//     className: "BedrockInstrumentation",
+//     requiredPackages: ["aws-sdk/client-bedrock-runtime"],
+//   },
+//   chromadb: {
+//     modulePath: "@traceloop/instrumentation-chromadb",
+//     className: "ChromaDBInstrumentation",
+//     requiredPackages: ["chromadb"],
+//   },
+//   cohere: {
+//     modulePath: "@traceloop/instrumentation-cohere",
+//     className: "CohereInstrumentation",
+//     requiredPackages: ["cohere-js"],
+//   },
+//   langchain: {
+//     modulePath: "@traceloop/instrumentation-langchain",
+//     className: "LangChainInstrumentation",
+//     requiredPackages: [
+//       "langchain",
+//       "@langchain/core",
+//       "@langchain/community",
+//       "@langchain/langgraph",
+//     ],
+//     init: (instrumentor: any) => {
+//       // eslint-disable-next-line @typescript-eslint/no-require-imports
+//       const module = require("./langchain.js") as { [key: string]: any };
+//       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+//       module.langchain(instrumentor);
+//     },
+//   },
+//   llamaindex: {
+//     modulePath: "@traceloop/instrumentation-llamaindex",
+//     className: "LlamaIndexInstrumentation",
+//     requiredPackages: ["llamaindex"],
+//   },
+//   openai: {
+//     modulePath: "@traceloop/instrumentation-openai",
+//     className: "OpenAIInstrumentation",
+//     requiredPackages: ["openai"],
+//   },
+//   pinecone: {
+//     modulePath: "@traceloop/instrumentation-pinecone",
+//     className: "PineconeInstrumentation",
+//     requiredPackages: ["pinecone-database/pinecone"],
+//   },
+//   qdrant: {
+//     modulePath: "@traceloop/instrumentation-qdrant",
+//     className: "QdrantInstrumentation",
+//     requiredPackages: ["qdrant/js-client-rest"],
+//   },
+//   vertexai: {
+//     modulePath: "@traceloop/instrumentation-vertexai",
+//     className: "VertexAIInstrumentation",
+//     requiredPackages: ["google-cloud/aiplatform"],
+//   },
+// };

package/dist/intex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/intex.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = __importDefault(require("./telemetry"));
+telemetry_1.default.init();

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+export declare const originalLogger: {
+    info: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    log: (message?: any, ...optionalParams: any[]) => void;
+};
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+export declare function stringify<T>(obj: T, maxDepth?: number, depth?: number): string;

package/dist/logger.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.originalLogger = void 0;
+exports.stringify = stringify;
+/* eslint-disable no-console */
+const api_logs_1 = require("@opentelemetry/api-logs");
+const telemetry_1 = require("./telemetry");
+exports.originalLogger = {
+    info: console.info,
+    error: console.error,
+    warn: console.warn,
+    debug: console.debug,
+    log: console.log,
+};
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+function stringify(obj, maxDepth = 1, depth = 0) {
+    if (obj instanceof Error)
+        return obj.stack || obj.message;
+    if (obj === null)
+        return 'null';
+    if (obj === undefined)
+        return 'undefined';
+    // If we've reached max depth or it's not an object
+    if (depth >= maxDepth || typeof obj !== 'object') {
+        return typeof obj === 'object' ? `[${Array.isArray(obj) ? 'Array' : 'object'}]` :
+            typeof obj === 'string' ? `"${obj}"` : String(obj);
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return `[${obj.map(item => stringify(item, maxDepth, depth + 1)).join(', ')}]`;
+    }
+    // Handle objects
+    const pairs = Object.entries(obj).map(([key, val]) => `"${key}": ${stringify(val, maxDepth, depth + 1)}`);
+    return `{${pairs.join(', ')}}`;
+}
+// Format a log message with appropriate color and prefix
+function formatLogMessage(message, args) {
+    const messageStr = typeof message === "string" ? message : stringify(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : stringify(arg, 2)).join(" ");
+    return `${messageStr}${argsStr ? " " + argsStr : ""}`;
+}
+async function emitLog(severityNumber, message) {
+    const loggerInstance = await telemetry_1.blaxelTelemetry.getLogger();
+    loggerInstance.emit({
+        severityNumber: severityNumber,
+        body: message,
+    });
+}
+function emitLogSync(severityNumber, message) {
+    emitLog(severityNumber, message).catch(() => { });
+}
+console.debug = (message, ...args) => {
+    const msg = formatLogMessage(message, args);
+    exports.originalLogger.log(msg);
+    emitLogSync(api_logs_1.SeverityNumber.DEBUG, msg);
+};
+console.log = (message, ...args) => {
+    const msg = formatLogMessage(message, args);
+    exports.originalLogger.log(msg);
+    emitLogSync(api_logs_1.SeverityNumber.INFO, msg);
+};
+console.info = (message, ...args) => {
+    const msg = formatLogMessage(message, args);
+    exports.originalLogger.log(msg);
+    emitLogSync(api_logs_1.SeverityNumber.INFO, msg);
+};
+console.error = (message, ...args) => {
+    const msg = formatLogMessage(message, args);
+    exports.originalLogger.log(msg);
+    emitLogSync(api_logs_1.SeverityNumber.ERROR, msg);
+};
+console.warn = (message, ...args) => {
+    const msg = formatLogMessage(message, args);
+    exports.originalLogger.log(msg);
+    emitLogSync(api_logs_1.SeverityNumber.WARN, msg);
+};

package/dist/telemetry.d.ts

@@ -0,0 +1,64 @@
+import { Span } from "@opentelemetry/api";
+import { Logger } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { RawResourceAttribute, Resource } from "@opentelemetry/resources";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-node";
+export declare class BlaxelResource implements Resource {
+    attributes: Record<string, string>;
+    constructor(attributes: Record<string, string>);
+    merge(other: Resource | null): Resource;
+    getRawAttributes(): RawResourceAttribute[];
+}
+export declare class DefaultAttributesSpanProcessor implements SpanProcessor {
+    private defaultAttributes;
+    constructor(defaultAttributes: Record<string, string>);
+    onStart(span: Span): void;
+    onEnd(): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+export type TelemetryOptions = {
+    workspace: string | null;
+    name: string | null;
+    authorization: string | null;
+    type: string | null;
+};
+declare class TelemetryManager {
+    private nodeTracerProvider;
+    private meterProvider;
+    private loggerProvider;
+    private otelLogger;
+    private initialized;
+    private configured;
+    constructor();
+    initialize(): void;
+    setConfiguration(): Promise<void>;
+    get enabled(): boolean;
+    get authHeaders(): Record<string, string>;
+    sleep(ms: number): Promise<unknown>;
+    getLogger(): Promise<Logger>;
+    setupSignalHandler(): void;
+    /**
+     * Get resource attributes for OpenTelemetry.
+     */
+    getResourceAttributes(): Promise<Record<string, string>>;
+    /**
+     * Initialize and return the OTLP Metric Exporter.
+     */
+    getMetricExporter(): OTLPMetricExporter;
+    /**
+     * Initialize and return the OTLP Trace Exporter.
+     */
+    getTraceExporter(): OTLPTraceExporter;
+    /**
+     * Initialize and return the OTLP Log Exporter.
+     */
+    getLogExporter(): OTLPLogExporter;
+    instrumentApp(): void;
+    setExporters(): Promise<void>;
+    shutdownApp(): Promise<void>;
+}
+export declare const blaxelTelemetry: TelemetryManager;
+export {};

package/dist/telemetry.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blaxelTelemetry = exports.DefaultAttributesSpanProcessor = exports.BlaxelResource = void 0;
+/* eslint-disable no-console */
+const core_1 = require("@blaxel/core");
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+class BlaxelResource {
+    attributes;
+    constructor(attributes) {
+        this.attributes = attributes;
+    }
+    merge(other) {
+        if (other?.attributes) {
+            for (const [key, value] of Object.entries(other.attributes)) {
+                if (typeof value === "string") {
+                    this.attributes[key] = value;
+                }
+            }
+        }
+        return this;
+    }
+    getRawAttributes() {
+        return Object.entries(this.attributes).map(([key, value]) => [key, value]);
+    }
+}
+exports.BlaxelResource = BlaxelResource;
+class DefaultAttributesSpanProcessor {
+    defaultAttributes;
+    constructor(defaultAttributes) {
+        this.defaultAttributes = defaultAttributes;
+    }
+    onStart(span) {
+        Object.entries(this.defaultAttributes).forEach(([key, value]) => {
+            span.setAttribute(key, value);
+        });
+    }
+    onEnd() { }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+exports.DefaultAttributesSpanProcessor = DefaultAttributesSpanProcessor;
+class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor {
+    onEnd(span) {
+        super.onEnd(span);
+    }
+}
+class TelemetryManager {
+    nodeTracerProvider;
+    meterProvider;
+    loggerProvider;
+    otelLogger;
+    initialized;
+    configured;
+    constructor() {
+        this.nodeTracerProvider = null;
+        this.meterProvider = null;
+        this.loggerProvider = null;
+        this.otelLogger = null;
+        this.initialized = false;
+        this.configured = false;
+    }
+    // This method need to stay sync to avoid non booted instrumentations
+    initialize() {
+        if (!this.enabled || this.initialized) {
+            return;
+        }
+        this.instrumentApp();
+        this.setupSignalHandler();
+        this.initialized = true;
+        this.setConfiguration().catch((error) => {
+            console.error("Error setting configuration:", error);
+        });
+    }
+    async setConfiguration() {
+        if (!this.enabled || this.configured) {
+            return;
+        }
+        await (0, core_1.authenticate)();
+        await this.setExporters();
+        this.otelLogger = api_logs_1.logs.getLogger("blaxel");
+        console.debug("Telemetry ready");
+        this.configured = true;
+    }
+    get enabled() {
+        return core_1.env.BL_ENABLE_OPENTELEMETRY === "true";
+    }
+    get authHeaders() {
+        const headers = {};
+        if (core_1.settings.authorization) {
+            headers["x-blaxel-authorization"] = core_1.settings.authorization;
+        }
+        if (core_1.settings.workspace) {
+            headers["x-blaxel-workspace"] = core_1.settings.workspace;
+        }
+        return headers;
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async getLogger() {
+        if (!this.otelLogger) {
+            await this.sleep(100);
+            return this.getLogger();
+        }
+        return this.otelLogger;
+    }
+    setupSignalHandler() {
+        const signals = ["SIGINT", "SIGTERM", "uncaughtException", "exit"];
+        for (const signal of signals) {
+            process.on(signal, (error) => {
+                if (signal !== "exit") {
+                    core_1.logger.error(error.stack);
+                }
+                this.shutdownApp().catch((error) => {
+                    console.debug("Fatal error during shutdown:", error);
+                    process.exit(0);
+                });
+            });
+        }
+    }
+    /**
+     * Get resource attributes for OpenTelemetry.
+     */
+    async getResourceAttributes() {
+        const resource = await resources_1.envDetector.detect();
+        const attributes = resource.attributes || {};
+        if (core_1.settings.name) {
+            attributes["service.name"] = core_1.settings.name;
+            attributes["workload.id"] = core_1.settings.name;
+        }
+        if (core_1.settings.workspace) {
+            attributes["workspace"] = core_1.settings.workspace;
+        }
+        if (core_1.settings.type) {
+            attributes["workload.type"] = core_1.settings.type + "s";
+        }
+        // Only keep string values
+        const stringAttrs = {};
+        for (const [k, v] of Object.entries(attributes)) {
+            if (typeof v === "string")
+                stringAttrs[k] = v;
+        }
+        return stringAttrs;
+    }
+    /**
+     * Initialize and return the OTLP Metric Exporter.
+     */
+    getMetricExporter() {
+        return new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+            headers: this.authHeaders,
+        });
+    }
+    /**
+     * Initialize and return the OTLP Trace Exporter.
+     */
+    getTraceExporter() {
+        return new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            headers: this.authHeaders,
+        });
+    }
+    /**
+     * Initialize and return the OTLP Log Exporter.
+     */
+    getLogExporter() {
+        return new exporter_logs_otlp_http_1.OTLPLogExporter({
+            headers: this.authHeaders,
+        });
+    }
+    instrumentApp() {
+        const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
+            requireParentforOutgoingSpans: true,
+        });
+        (0, instrumentation_1.registerInstrumentations)({
+            instrumentations: [httpInstrumentation],
+        });
+    }
+    async setExporters() {
+        const resource = new BlaxelResource(await this.getResourceAttributes());
+        const logExporter = this.getLogExporter();
+        this.loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource,
+        });
+        this.loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
+        api_logs_1.logs.setGlobalLoggerProvider(this.loggerProvider);
+        const traceExporter = this.getTraceExporter();
+        this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            resource,
+            sampler: new sdk_trace_node_1.AlwaysOnSampler(),
+            spanProcessors: [
+                new DefaultAttributesSpanProcessor({
+                    "workload.id": core_1.settings.name || "",
+                    "workload.type": core_1.settings.type ? core_1.settings.type + "s" : "",
+                    workspace: core_1.settings.workspace || "",
+                }),
+                new sdk_trace_node_1.BatchSpanProcessor(traceExporter),
+                new HasBeenProcessedSpanProcessor(traceExporter),
+            ],
+        });
+        this.nodeTracerProvider.register();
+        const metricExporter = this.getMetricExporter();
+        this.meterProvider = new sdk_metrics_1.MeterProvider({
+            resource,
+            readers: [
+                new sdk_metrics_1.PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: 60000,
+                }),
+            ],
+        });
+        api_1.metrics.setGlobalMeterProvider(this.meterProvider);
+    }
+    async shutdownApp() {
+        try {
+            const maxSleepTime = 5000;
+            const startTime = Date.now();
+            while (!this.configured && Date.now() - startTime < maxSleepTime) {
+                await this.sleep(100);
+            }
+            const shutdownPromises = [];
+            if (this.nodeTracerProvider) {
+                shutdownPromises.push(this.nodeTracerProvider
+                    .shutdown()
+                    .catch((error) => console.debug("Error shutting down tracer provider:", error)));
+            }
+            if (this.meterProvider) {
+                shutdownPromises.push(this.meterProvider
+                    .shutdown()
+                    .catch((error) => console.debug("Error shutting down meter provider:", error)));
+            }
+            if (this.loggerProvider) {
+                shutdownPromises.push(this.loggerProvider
+                    .shutdown()
+                    .catch((error) => console.debug("Error shutting down logger provider:", error)));
+            }
+            // Wait for all providers to shutdown with a timeout
+            await Promise.race([
+                Promise.all(shutdownPromises),
+                new Promise((resolve) => setTimeout(resolve, 5000)), // 5 second timeout
+            ]);
+            console.debug("Instrumentation shutdown complete");
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("Error during shutdown:", error);
+            process.exit(1);
+        }
+    }
+}
+exports.blaxelTelemetry = new TelemetryManager();

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@blaxel/telemetry",
+  "version": "0.2.0-dev1",
+  "description": "Blaxel SDK for TypeScript",
+  "license": "MIT",
+  "author": "Blaxel, INC (https://blaxel.ai)",
+  "homepage": "https://blaxel.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blaxel/toolkit/sdk-ts"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "blaxel",
+    "agent",
+    "mcp"
+  ],
+  "main": "dist/index.js",
+  "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./*": {
+      "import": {
+        "types": "./dist/*.d.ts",
+        "default": "./dist/*.js"
+      },
+      "require": {
+        "types": "./dist/*.d.ts",
+        "default": "./dist/*.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1.2.10",
+    "@ai-sdk/cerebras": "^0.2.13",
+    "@ai-sdk/google": "^1.2.14",
+    "@ai-sdk/groq": "^1.2.8",
+    "@ai-sdk/openai": "^1.3.21",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.200.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.200.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.200.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.200.0",
+    "@opentelemetry/instrumentation": "^0.200.0",
+    "@opentelemetry/instrumentation-http": "^0.200.0",
+    "@opentelemetry/resources": "^2.0.0",
+    "@opentelemetry/sdk-logs": "^0.200.0",
+    "@opentelemetry/sdk-metrics": "^2.0.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.0",
+    "@opentelemetry/sdk-trace-node": "^2.0.0",
+    "ai": "^4.3.13",
+    "@blaxel/core": "0.2.0-dev1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.31.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src/"
+  }
+}