@openconductor/mcp-sdk 0.2.0

package/dist/errors/index.mjs

@@ -0,0 +1,146 @@
+// src/errors/codes.ts
+var ErrorCodes = {
+  // JSON-RPC 2.0 Standard Errors
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // MCP-Specific Errors (-32000 to -32099 reserved for implementation)
+  TOOL_NOT_FOUND: -32001,
+  TOOL_EXECUTION_ERROR: -32002,
+  RESOURCE_NOT_FOUND: -32003,
+  AUTHENTICATION_ERROR: -32004,
+  AUTHORIZATION_ERROR: -32005,
+  RATE_LIMIT_ERROR: -32006,
+  TIMEOUT_ERROR: -32007,
+  VALIDATION_ERROR: -32008,
+  DEPENDENCY_ERROR: -32009,
+  CONFIGURATION_ERROR: -32010
+};
+
+// src/errors/index.ts
+var MCPError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "MCPError";
+    this.code = code;
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Returns JSON-RPC 2.0 formatted error object
+   */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.data && { data: this.data }
+    };
+  }
+  /**
+   * Create error response for JSON-RPC
+   */
+  toResponse(id = null) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: this.toJSON()
+    };
+  }
+};
+var ValidationError = class extends MCPError {
+  constructor(field, reason, value) {
+    super(ErrorCodes.INVALID_PARAMS, `Validation failed for '${field}': ${reason}`, {
+      field,
+      reason,
+      ...value !== void 0 && { value }
+    });
+    this.name = "ValidationError";
+  }
+};
+var ToolNotFoundError = class extends MCPError {
+  constructor(toolName) {
+    super(ErrorCodes.TOOL_NOT_FOUND, `Tool '${toolName}' not found`, {
+      tool: toolName
+    });
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolExecutionError = class extends MCPError {
+  constructor(toolName, reason, cause) {
+    super(ErrorCodes.TOOL_EXECUTION_ERROR, `Tool '${toolName}' failed: ${reason}`, {
+      tool: toolName,
+      reason,
+      ...cause && { cause: cause.message }
+    });
+    this.name = "ToolExecutionError";
+  }
+};
+var ResourceNotFoundError = class extends MCPError {
+  constructor(resourceUri) {
+    super(ErrorCodes.RESOURCE_NOT_FOUND, `Resource '${resourceUri}' not found`, {
+      uri: resourceUri
+    });
+    this.name = "ResourceNotFoundError";
+  }
+};
+var AuthenticationError = class extends MCPError {
+  constructor(reason = "Authentication required") {
+    super(ErrorCodes.AUTHENTICATION_ERROR, reason);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends MCPError {
+  constructor(action, resource) {
+    const msg = resource ? `Not authorized to ${action} on '${resource}'` : `Not authorized to ${action}`;
+    super(ErrorCodes.AUTHORIZATION_ERROR, msg, {
+      action,
+      ...resource && { resource }
+    });
+    this.name = "AuthorizationError";
+  }
+};
+var RateLimitError = class extends MCPError {
+  constructor(retryAfterMs) {
+    super(ErrorCodes.RATE_LIMIT_ERROR, "Rate limit exceeded", {
+      ...retryAfterMs && { retryAfterMs }
+    });
+    this.name = "RateLimitError";
+  }
+};
+var TimeoutError = class extends MCPError {
+  constructor(operation, timeoutMs) {
+    super(ErrorCodes.TIMEOUT_ERROR, `Operation '${operation}' timed out after ${timeoutMs}ms`, {
+      operation,
+      timeoutMs
+    });
+    this.name = "TimeoutError";
+  }
+};
+var DependencyError = class extends MCPError {
+  constructor(dependency, reason) {
+    super(ErrorCodes.DEPENDENCY_ERROR, `Dependency '${dependency}' unavailable: ${reason}`, {
+      dependency,
+      reason
+    });
+    this.name = "DependencyError";
+  }
+};
+var ConfigurationError = class extends MCPError {
+  constructor(setting, reason) {
+    super(ErrorCodes.CONFIGURATION_ERROR, `Invalid configuration '${setting}': ${reason}`, {
+      setting,
+      reason
+    });
+    this.name = "ConfigurationError";
+  }
+};
+
+export { AuthenticationError, AuthorizationError, ConfigurationError, DependencyError, ErrorCodes, MCPError, RateLimitError, ResourceNotFoundError, TimeoutError, ToolExecutionError, ToolNotFoundError, ValidationError };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/errors/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors/codes.ts","../../src/errors/index.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * JSON-RPC 2.0 Standard Error Codes\n * https://www.jsonrpc.org/specification#error_object\n */\nexport const ErrorCodes = {\n  // JSON-RPC 2.0 Standard Errors\n  PARSE_ERROR: -32700,\n  INVALID_REQUEST: -32600,\n  METHOD_NOT_FOUND: -32601,\n  INVALID_PARAMS: -32602,\n  INTERNAL_ERROR: -32603,\n\n  // MCP-Specific Errors (-32000 to -32099 reserved for implementation)\n  TOOL_NOT_FOUND: -32001,\n  TOOL_EXECUTION_ERROR: -32002,\n  RESOURCE_NOT_FOUND: -32003,\n  AUTHENTICATION_ERROR: -32004,\n  AUTHORIZATION_ERROR: -32005,\n  RATE_LIMIT_ERROR: -32006,\n  TIMEOUT_ERROR: -32007,\n  VALIDATION_ERROR: -32008,\n  DEPENDENCY_ERROR: -32009,\n  CONFIGURATION_ERROR: -32010,\n} as const\n\nexport type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes]\n","import { ErrorCodes, type ErrorCode } from './codes'\n\nexport { ErrorCodes, type ErrorCode } from './codes'\n\n/**\n * Base error class for MCP servers\n * Formats errors according to JSON-RPC 2.0 specification\n */\nexport class MCPError extends Error {\n  public readonly code: ErrorCode\n  public readonly data?: Record<string, unknown>\n\n  constructor(\n    code: ErrorCode,\n    message: string,\n    data?: Record<string, unknown>\n  ) {\n    super(message)\n    this.name = 'MCPError'\n    this.code = code\n    this.data = data\n\n    // Maintains proper stack trace in V8 environments\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor)\n    }\n  }\n\n  /**\n   * Returns JSON-RPC 2.0 formatted error object\n   */\n  toJSON() {\n    return {\n      code: this.code,\n      message: this.message,\n      ...(this.data && { data: this.data }),\n    }\n  }\n\n  /**\n   * Create error response for JSON-RPC\n   */\n  toResponse(id: string | number | null = null) {\n    return {\n      jsonrpc: '2.0' as const,\n      id,\n      error: this.toJSON(),\n    }\n  }\n}\n\n/**\n * Thrown when tool input validation fails\n */\nexport class ValidationError extends MCPError {\n  constructor(field: string, reason: string, value?: unknown) {\n    super(ErrorCodes.INVALID_PARAMS, `Validation failed for '${field}': ${reason}`, {\n      field,\n      reason,\n      ...(value !== undefined && { value }),\n    })\n    this.name = 'ValidationError'\n  }\n}\n\n/**\n * Thrown when a requested tool doesn't exist\n */\nexport class ToolNotFoundError extends MCPError {\n  constructor(toolName: string) {\n    super(ErrorCodes.TOOL_NOT_FOUND, `Tool '${toolName}' not found`, {\n      tool: toolName,\n    })\n    this.name = 'ToolNotFoundError'\n  }\n}\n\n/**\n * Thrown when tool execution fails\n */\nexport class ToolExecutionError extends MCPError {\n  constructor(toolName: string, reason: string, cause?: Error) {\n    super(ErrorCodes.TOOL_EXECUTION_ERROR, `Tool '${toolName}' failed: ${reason}`, {\n      tool: toolName,\n      reason,\n      ...(cause && { cause: cause.message }),\n    })\n    this.name = 'ToolExecutionError'\n  }\n}\n\n/**\n * Thrown when a requested resource doesn't exist\n */\nexport class ResourceNotFoundError extends MCPError {\n  constructor(resourceUri: string) {\n    super(ErrorCodes.RESOURCE_NOT_FOUND, `Resource '${resourceUri}' not found`, {\n      uri: resourceUri,\n    })\n    this.name = 'ResourceNotFoundError'\n  }\n}\n\n/**\n * Thrown when authentication fails\n */\nexport class AuthenticationError extends MCPError {\n  constructor(reason: string = 'Authentication required') {\n    super(ErrorCodes.AUTHENTICATION_ERROR, reason)\n    this.name = 'AuthenticationError'\n  }\n}\n\n/**\n * Thrown when authorization fails (authenticated but not permitted)\n */\nexport class AuthorizationError extends MCPError {\n  constructor(action: string, resource?: string) {\n    const msg = resource\n      ? `Not authorized to ${action} on '${resource}'`\n      : `Not authorized to ${action}`\n    super(ErrorCodes.AUTHORIZATION_ERROR, msg, {\n      action,\n      ...(resource && { resource }),\n    })\n    this.name = 'AuthorizationError'\n  }\n}\n\n/**\n * Thrown when rate limits are exceeded\n */\nexport class RateLimitError extends MCPError {\n  constructor(retryAfterMs?: number) {\n    super(ErrorCodes.RATE_LIMIT_ERROR, 'Rate limit exceeded', {\n      ...(retryAfterMs && { retryAfterMs }),\n    })\n    this.name = 'RateLimitError'\n  }\n}\n\n/**\n * Thrown when an operation times out\n */\nexport class TimeoutError extends MCPError {\n  constructor(operation: string, timeoutMs: number) {\n    super(ErrorCodes.TIMEOUT_ERROR, `Operation '${operation}' timed out after ${timeoutMs}ms`, {\n      operation,\n      timeoutMs,\n    })\n    this.name = 'TimeoutError'\n  }\n}\n\n/**\n * Thrown when a required dependency is unavailable\n */\nexport class DependencyError extends MCPError {\n  constructor(dependency: string, reason: string) {\n    super(ErrorCodes.DEPENDENCY_ERROR, `Dependency '${dependency}' unavailable: ${reason}`, {\n      dependency,\n      reason,\n    })\n    this.name = 'DependencyError'\n  }\n}\n\n/**\n * Thrown when server configuration is invalid\n */\nexport class ConfigurationError extends MCPError {\n  constructor(setting: string, reason: string) {\n    super(ErrorCodes.CONFIGURATION_ERROR, `Invalid configuration '${setting}': ${reason}`, {\n      setting,\n      reason,\n    })\n    this.name = 'ConfigurationError'\n  }\n}\n"]}

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+export { AuthenticationError, AuthorizationError, ConfigurationError, DependencyError, ErrorCode, ErrorCodes, MCPError, RateLimitError, ResourceNotFoundError, TimeoutError, ToolExecutionError, ToolNotFoundError, ValidationError } from './errors/index.mjs';
+export { Infer, ValidateOptions, schemas, validate, validateInput } from './validate/index.mjs';
+export { LogEntry, LogLevel, Logger, LoggerOptions, createLogger } from './logger/index.mjs';
+export { HealthCheckInfo, HealthCheckResponse, ToolContext, WrapToolOptions, createHealthCheck, wrapTool } from './server/index.mjs';
+export { Telemetry, TelemetryBatch, TelemetryConfig, ToolMetric, getTelemetry, initTelemetry } from './telemetry/index.mjs';
+export { ZodError, ZodSchema, z } from 'zod';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { AuthenticationError, AuthorizationError, ConfigurationError, DependencyError, ErrorCode, ErrorCodes, MCPError, RateLimitError, ResourceNotFoundError, TimeoutError, ToolExecutionError, ToolNotFoundError, ValidationError } from './errors/index.js';
+export { Infer, ValidateOptions, schemas, validate, validateInput } from './validate/index.js';
+export { LogEntry, LogLevel, Logger, LoggerOptions, createLogger } from './logger/index.js';
+export { HealthCheckInfo, HealthCheckResponse, ToolContext, WrapToolOptions, createHealthCheck, wrapTool } from './server/index.js';
+export { Telemetry, TelemetryBatch, TelemetryConfig, ToolMetric, getTelemetry, initTelemetry } from './telemetry/index.js';
+export { ZodError, ZodSchema, z } from 'zod';

package/dist/index.js

@@ -0,0 +1,524 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/errors/codes.ts
+var ErrorCodes = {
+  // JSON-RPC 2.0 Standard Errors
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // MCP-Specific Errors (-32000 to -32099 reserved for implementation)
+  TOOL_NOT_FOUND: -32001,
+  TOOL_EXECUTION_ERROR: -32002,
+  RESOURCE_NOT_FOUND: -32003,
+  AUTHENTICATION_ERROR: -32004,
+  AUTHORIZATION_ERROR: -32005,
+  RATE_LIMIT_ERROR: -32006,
+  TIMEOUT_ERROR: -32007,
+  VALIDATION_ERROR: -32008,
+  DEPENDENCY_ERROR: -32009,
+  CONFIGURATION_ERROR: -32010
+};
+
+// src/errors/index.ts
+var MCPError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "MCPError";
+    this.code = code;
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Returns JSON-RPC 2.0 formatted error object
+   */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.data && { data: this.data }
+    };
+  }
+  /**
+   * Create error response for JSON-RPC
+   */
+  toResponse(id = null) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: this.toJSON()
+    };
+  }
+};
+var ValidationError = class extends MCPError {
+  constructor(field, reason, value) {
+    super(ErrorCodes.INVALID_PARAMS, `Validation failed for '${field}': ${reason}`, {
+      field,
+      reason,
+      ...value !== void 0 && { value }
+    });
+    this.name = "ValidationError";
+  }
+};
+var ToolNotFoundError = class extends MCPError {
+  constructor(toolName) {
+    super(ErrorCodes.TOOL_NOT_FOUND, `Tool '${toolName}' not found`, {
+      tool: toolName
+    });
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolExecutionError = class extends MCPError {
+  constructor(toolName, reason, cause) {
+    super(ErrorCodes.TOOL_EXECUTION_ERROR, `Tool '${toolName}' failed: ${reason}`, {
+      tool: toolName,
+      reason,
+      ...cause && { cause: cause.message }
+    });
+    this.name = "ToolExecutionError";
+  }
+};
+var ResourceNotFoundError = class extends MCPError {
+  constructor(resourceUri) {
+    super(ErrorCodes.RESOURCE_NOT_FOUND, `Resource '${resourceUri}' not found`, {
+      uri: resourceUri
+    });
+    this.name = "ResourceNotFoundError";
+  }
+};
+var AuthenticationError = class extends MCPError {
+  constructor(reason = "Authentication required") {
+    super(ErrorCodes.AUTHENTICATION_ERROR, reason);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends MCPError {
+  constructor(action, resource) {
+    const msg = resource ? `Not authorized to ${action} on '${resource}'` : `Not authorized to ${action}`;
+    super(ErrorCodes.AUTHORIZATION_ERROR, msg, {
+      action,
+      ...resource && { resource }
+    });
+    this.name = "AuthorizationError";
+  }
+};
+var RateLimitError = class extends MCPError {
+  constructor(retryAfterMs) {
+    super(ErrorCodes.RATE_LIMIT_ERROR, "Rate limit exceeded", {
+      ...retryAfterMs && { retryAfterMs }
+    });
+    this.name = "RateLimitError";
+  }
+};
+var TimeoutError = class extends MCPError {
+  constructor(operation, timeoutMs) {
+    super(ErrorCodes.TIMEOUT_ERROR, `Operation '${operation}' timed out after ${timeoutMs}ms`, {
+      operation,
+      timeoutMs
+    });
+    this.name = "TimeoutError";
+  }
+};
+var DependencyError = class extends MCPError {
+  constructor(dependency, reason) {
+    super(ErrorCodes.DEPENDENCY_ERROR, `Dependency '${dependency}' unavailable: ${reason}`, {
+      dependency,
+      reason
+    });
+    this.name = "DependencyError";
+  }
+};
+var ConfigurationError = class extends MCPError {
+  constructor(setting, reason) {
+    super(ErrorCodes.CONFIGURATION_ERROR, `Invalid configuration '${setting}': ${reason}`, {
+      setting,
+      reason
+    });
+    this.name = "ConfigurationError";
+  }
+};
+function validate(schema, input, options = {}) {
+  const { stripUnknown = true } = options;
+  const result = stripUnknown ? schema.safeParse(input) : schema instanceof zod.z.ZodObject ? schema.strict().safeParse(input) : schema.safeParse(input);
+  if (!result.success) {
+    const firstError = result.error.errors[0];
+    const field = firstError.path.join(".") || "input";
+    const reason = firstError.message;
+    throw new ValidationError(
+      field,
+      reason,
+      firstError.path.length > 0 ? getNestedValue(input, firstError.path) : input
+    );
+  }
+  return result.data;
+}
+function validateInput(schema, handler, options = {}) {
+  return async (input) => {
+    const validated = validate(schema, input, options);
+    return handler(validated);
+  };
+}
+function getNestedValue(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+var schemas = {
+  /** Non-empty string */
+  nonEmptyString: zod.z.string().min(1, "Cannot be empty"),
+  /** Positive integer */
+  positiveInt: zod.z.number().int().positive(),
+  /** Pagination limit (1-100, default 10) */
+  limit: zod.z.number().int().min(1).max(100).default(10),
+  /** Pagination offset (>= 0, default 0) */
+  offset: zod.z.number().int().min(0).default(0),
+  /** URL string */
+  url: zod.z.string().url(),
+  /** Email string */
+  email: zod.z.string().email(),
+  /** UUID string */
+  uuid: zod.z.string().uuid(),
+  /** ISO date string */
+  isoDate: zod.z.string().datetime(),
+  /** Boolean with string coercion ('true'/'false' -> boolean) */
+  booleanish: zod.z.union([
+    zod.z.boolean(),
+    zod.z.enum(["true", "false"]).transform((v) => v === "true")
+  ])
+};
+
+// src/logger/index.ts
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(service, options = {}) {
+  const {
+    level: minLevel = "info",
+    timestamps = true,
+    pretty = false
+  } = options;
+  const shouldLog = (level) => {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[minLevel];
+  };
+  const formatEntry = (entry) => {
+    return pretty ? JSON.stringify(entry, null, 2) : JSON.stringify(entry);
+  };
+  const log = (level, message, data) => {
+    if (!shouldLog(level)) return;
+    const entry = {
+      ...timestamps && { timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+      level,
+      service,
+      message,
+      ...data
+    };
+    if (options.output) {
+      options.output(entry);
+    } else {
+      const formatted = formatEntry(entry);
+      switch (level) {
+        case "debug":
+          console.debug(formatted);
+          break;
+        case "info":
+          console.info(formatted);
+          break;
+        case "warn":
+          console.warn(formatted);
+          break;
+        case "error":
+          console.error(formatted);
+          break;
+      }
+    }
+    return entry;
+  };
+  return {
+    debug: (message, data) => log("debug", message, data),
+    info: (message, data) => log("info", message, data),
+    warn: (message, data) => log("warn", message, data),
+    error: (message, data) => log("error", message, data),
+    /**
+     * Create a child logger with additional context
+     */
+    child: (context) => {
+      return createLogger(service, {
+        ...options,
+        output: (entry) => {
+          const merged = { ...entry, ...context };
+          if (options.output) {
+            options.output(merged);
+          } else {
+            const formatted = pretty ? JSON.stringify(merged, null, 2) : JSON.stringify(merged);
+            console[entry.level](formatted);
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/telemetry/index.ts
+var SDK_VERSION = "0.2.0";
+var DEFAULT_ENDPOINT = "https://api.openconductor.ai/functions/v1/telemetry";
+var globalTelemetry = null;
+function initTelemetry(config) {
+  globalTelemetry = new Telemetry(config);
+  return globalTelemetry;
+}
+function getTelemetry() {
+  return globalTelemetry;
+}
+var Telemetry = class {
+  config;
+  buffer = [];
+  flushTimer = null;
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      serverName: config.serverName,
+      serverVersion: config.serverVersion,
+      endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+      batchSize: config.batchSize ?? 10,
+      flushInterval: config.flushInterval ?? 3e4,
+      debug: config.debug ?? false
+    };
+    this.flushTimer = setInterval(() => {
+      this.flush().catch(this.handleError.bind(this));
+    }, this.config.flushInterval);
+    if (typeof process !== "undefined") {
+      process.on("beforeExit", () => this.flush());
+      process.on("SIGINT", () => {
+        this.flush().finally(() => process.exit(0));
+      });
+      process.on("SIGTERM", () => {
+        this.flush().finally(() => process.exit(0));
+      });
+    }
+    this.log("Telemetry initialized", { serverName: config.serverName });
+  }
+  /**
+   * Track a tool invocation
+   */
+  trackToolCall(tool, duration, success, error) {
+    const metric = {
+      tool,
+      duration,
+      success,
+      ...error && { error },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.buffer.push(metric);
+    this.log("Metric tracked", { ...metric });
+    if (this.buffer.length >= this.config.batchSize) {
+      this.flush().catch(this.handleError.bind(this));
+    }
+  }
+  /**
+   * Flush buffered metrics to OpenConductor
+   */
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const metrics = [...this.buffer];
+    this.buffer = [];
+    const batch = {
+      serverName: this.config.serverName,
+      serverVersion: this.config.serverVersion,
+      metrics,
+      meta: {
+        sdkVersion: SDK_VERSION,
+        nodeVersion: typeof process !== "undefined" ? process.version : "unknown",
+        platform: typeof process !== "undefined" ? process.platform : "unknown"
+      }
+    };
+    this.log("Flushing metrics", { count: metrics.length });
+    try {
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "X-OpenConductor-SDK": SDK_VERSION
+        },
+        body: JSON.stringify(batch)
+      });
+      if (!response.ok) {
+        throw new Error(`Telemetry flush failed: ${response.status} ${response.statusText}`);
+      }
+      this.log("Metrics flushed successfully", { count: metrics.length });
+    } catch (error) {
+      this.buffer.unshift(...metrics);
+      throw error;
+    }
+  }
+  /**
+   * Stop telemetry collection
+   */
+  shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush().catch(this.handleError.bind(this));
+    this.log("Telemetry shutdown");
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.debug(JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "debug",
+        service: "openconductor-telemetry",
+        message,
+        ...data
+      }));
+    }
+  }
+  handleError(error) {
+    if (this.config.debug) {
+      console.error("[OpenConductor Telemetry Error]", error);
+    }
+  }
+};
+
+// src/server/index.ts
+function createHealthCheck(info) {
+  return async () => {
+    const checks = {};
+    let allHealthy = true;
+    if (info.checks) {
+      for (const [name, check] of Object.entries(info.checks)) {
+        try {
+          checks[name] = await check();
+          if (!checks[name]) allHealthy = false;
+        } catch {
+          checks[name] = false;
+          allHealthy = false;
+        }
+      }
+    }
+    return {
+      status: allHealthy ? "healthy" : "degraded",
+      name: info.name,
+      version: info.version,
+      ...info.description && { description: info.description },
+      ...info.uptime && { uptime: info.uptime() },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...Object.keys(checks).length > 0 && { checks }
+    };
+  };
+}
+function wrapTool(handler, options) {
+  const {
+    name,
+    timeout = 3e4,
+    telemetry: enableTelemetry = true
+  } = options;
+  const baseLogger = options.logger ?? createLogger(name);
+  return async (input) => {
+    const callId = generateCallId();
+    const startTime = Date.now();
+    const log = baseLogger.child({ callId });
+    const ctx = { callId, name, startTime, log };
+    log.info("Tool invoked", { tool: name, input: sanitizeInput(input) });
+    try {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new TimeoutError(name, timeout));
+        }, timeout);
+      });
+      const result = await Promise.race([
+        Promise.resolve(handler(input, ctx)),
+        timeoutPromise
+      ]);
+      const duration = Date.now() - startTime;
+      log.info("Tool completed", { tool: name, duration });
+      if (enableTelemetry) {
+        const tel = getTelemetry();
+        tel?.trackToolCall(name, duration, true);
+      }
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log.error("Tool failed", {
+        tool: name,
+        duration,
+        error: errorMessage,
+        stack: error instanceof Error ? error.stack : void 0
+      });
+      if (enableTelemetry) {
+        const tel = getTelemetry();
+        tel?.trackToolCall(name, duration, false, errorMessage);
+      }
+      if (error instanceof MCPError) {
+        throw error;
+      }
+      throw new ToolExecutionError(
+        name,
+        errorMessage,
+        error instanceof Error ? error : void 0
+      );
+    }
+  };
+}
+function generateCallId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function sanitizeInput(input) {
+  if (typeof input !== "object" || input === null) return input;
+  const sensitiveKeys = ["password", "token", "secret", "key", "auth", "credential"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (sensitiveKeys.some((k) => key.toLowerCase().includes(k))) {
+      sanitized[key] = "[REDACTED]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+Object.defineProperty(exports, "ZodError", {
+  enumerable: true,
+  get: function () { return zod.ZodError; }
+});
+Object.defineProperty(exports, "z", {
+  enumerable: true,
+  get: function () { return zod.z; }
+});
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.ConfigurationError = ConfigurationError;
+exports.DependencyError = DependencyError;
+exports.ErrorCodes = ErrorCodes;
+exports.MCPError = MCPError;
+exports.RateLimitError = RateLimitError;
+exports.ResourceNotFoundError = ResourceNotFoundError;
+exports.Telemetry = Telemetry;
+exports.TimeoutError = TimeoutError;
+exports.ToolExecutionError = ToolExecutionError;
+exports.ToolNotFoundError = ToolNotFoundError;
+exports.ValidationError = ValidationError;
+exports.createHealthCheck = createHealthCheck;
+exports.createLogger = createLogger;
+exports.getTelemetry = getTelemetry;
+exports.initTelemetry = initTelemetry;
+exports.schemas = schemas;
+exports.validate = validate;
+exports.validateInput = validateInput;
+exports.wrapTool = wrapTool;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map