@neuronetiq/marketplace-contracts/dist/index.mjs

Contracts for ML Marketplace - Pod I/O, Marketplace API, and Infra Integration

import { z } from 'zod';

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/schemas/infra-write.ts
var infra_write_exports = {};
__export(infra_write_exports, {
  BatchConsensusWrite: () => BatchConsensusWrite,
  BatchSignalWrite: () => BatchSignalWrite,
  ConsensusWrite: () => ConsensusWrite,
  ConsensusWriteRequest: () => ConsensusWriteRequest,
  MarketplaceHeaders: () => MarketplaceHeaders,
  SignalWrite: () => SignalWrite,
  SignalWriteRequest: () => SignalWriteRequest,
  WriteResponse: () => WriteResponse
});
var ISODateTime3, UUID3, Symbol3, Timeframe2, Decision2, Confidence2, SignalWrite, ConsensusWrite, BatchSignalWrite, BatchConsensusWrite, SignalWriteRequest, ConsensusWriteRequest, WriteResponse, MarketplaceHeaders;
var init_infra_write = __esm({
  "src/schemas/infra-write.ts"() {
    ISODateTime3 = z.string().datetime();
    UUID3 = z.string().uuid();
    Symbol3 = z.string().min(1).max(10);
    Timeframe2 = z.enum(["1m", "5m", "15m", "1h", "4h", "1d"]);
    Decision2 = z.enum(["BUY", "SELL", "HOLD", "UNKNOWN"]);
    Confidence2 = z.number().min(0).max(1);
    SignalWrite = z.object({
      // Core signal data
      symbol: Symbol3,
      timeframe: Timeframe2,
      decision: Decision2,
      confidence: Confidence2,
      model_version: z.string(),
      timestamp: ISODateTime3,
      // Vendor attribution
      vendor_id: z.string().min(1).max(50),
      deployment_id: UUID3,
      // Optional metadata
      rationale: z.array(z.string()).optional(),
      metadata: z.record(z.any()).optional(),
      // Model performance context
      model_performance: z.object({
        backtest_sharpe: z.number().optional(),
        live_sharpe: z.number().optional(),
        win_rate: z.number().min(0).max(1).optional(),
        max_drawdown: z.number().min(0).max(1).optional()
      }).optional(),
      // Feature importance (optional)
      feature_importance: z.record(z.number()).optional(),
      // Prediction uncertainty
      uncertainty: z.number().min(0).max(1).optional()
    }).strict();
    ConsensusWrite = z.object({
      // Core consensus data
      symbol: Symbol3,
      timeframe: Timeframe2,
      decision: Decision2,
      confidence: Confidence2,
      model_version: z.string(),
      timestamp: ISODateTime3,
      // Vendor attribution
      vendor_id: z.string().min(1).max(50),
      deployment_id: UUID3,
      // Consensus details
      contributing_models: z.array(z.object({
        model_id: z.string(),
        vendor_id: z.string(),
        weight: z.number().min(0).max(1),
        contribution: z.number().min(-1).max(1)
      })).optional(),
      // Optional metadata
      rationale: z.array(z.string()).optional(),
      metadata: z.record(z.any()).optional(),
      // Consensus metrics
      consensus_metrics: z.object({
        agreement_score: z.number().min(0).max(1).optional(),
        diversity_index: z.number().min(0).max(1).optional(),
        confidence_interval: z.object({
          lower: z.number().min(0).max(1),
          upper: z.number().min(0).max(1)
        }).optional()
      }).optional(),
      // Model performance context
      model_performance: z.object({
        backtest_sharpe: z.number().optional(),
        live_sharpe: z.number().optional(),
        win_rate: z.number().min(0).max(1).optional(),
        max_drawdown: z.number().min(0).max(1).optional()
      }).optional()
    }).strict();
    BatchSignalWrite = z.object({
      signals: z.array(SignalWrite).min(1).max(100),
      // Batch metadata
      batch_id: UUID3.optional(),
      vendor_id: z.string().min(1).max(50),
      deployment_id: UUID3,
      timestamp: ISODateTime3
    }).strict();
    BatchConsensusWrite = z.object({
      consensus: z.array(ConsensusWrite).min(1).max(100),
      // Batch metadata
      batch_id: UUID3.optional(),
      vendor_id: z.string().min(1).max(50),
      deployment_id: UUID3,
      timestamp: ISODateTime3
    }).strict();
    SignalWriteRequest = z.union([
      SignalWrite,
      BatchSignalWrite
    ]);
    ConsensusWriteRequest = z.union([
      ConsensusWrite,
      BatchConsensusWrite
    ]);
    WriteResponse = z.object({
      success: z.boolean(),
      message: z.string().optional(),
      // Request tracking
      request_id: UUID3,
      timestamp: ISODateTime3,
      // Write results
      results: z.object({
        written: z.number().int().nonnegative(),
        skipped: z.number().int().nonnegative().optional(),
        errors: z.number().int().nonnegative().optional()
      }).optional(),
      // Error details
      errors: z.array(z.object({
        code: z.string(),
        message: z.string(),
        data: z.any().optional()
      })).optional(),
      // Idempotency information
      idempotency: z.object({
        key: z.string(),
        slot: z.number().int().nonnegative(),
        was_duplicate: z.boolean()
      }).optional()
    }).strict();
    MarketplaceHeaders = z.object({
      "Authorization": z.string().regex(/^Bearer\s+.+$/),
      "X-Marketplace-Contracts-Version": z.string().regex(/^\d+\.\d+\.\d+$/),
      "X-Idempotency-Key": z.string().optional(),
      "X-Vendor-ID": z.string().optional(),
      "X-Deployment-ID": z.string().optional(),
      "Content-Type": z.literal("application/json")
    }).strict();
  }
});
var ISODateTime = z.string().datetime();
var UUID = z.string().uuid();
var Symbol2 = z.string().min(1).max(10);
var Timeframe = z.enum(["1m", "5m", "15m", "1h", "4h", "1d"]);
var Decision = z.enum(["BUY", "SELL", "HOLD", "UNKNOWN"]);
var Confidence = z.number().min(0).max(1);
var SignalInferenceRequest = z.object({
  // Request metadata
  request_id: UUID,
  timestamp: ISODateTime,
  // Market context
  symbol: Symbol2,
  timeframe: Timeframe,
  // Market data (last N bars)
  bars: z.array(z.object({
    timestamp: ISODateTime,
    open: z.number().positive(),
    high: z.number().positive(),
    low: z.number().positive(),
    close: z.number().positive(),
    volume: z.number().nonnegative()
  })).min(1).max(1e3),
  // Model configuration
  model_config: z.object({
    model_version: z.string().optional(),
    features: z.array(z.string()).optional(),
    parameters: z.record(z.any()).optional()
  }).optional(),
  // Optional context
  context: z.object({
    market_session: z.enum(["pre", "regular", "post"]).optional(),
    volatility_regime: z.enum(["low", "normal", "high"]).optional(),
    news_sentiment: z.number().min(-1).max(1).optional()
  }).optional()
}).strict();
var SignalInferenceResponse = z.object({
  // Response metadata
  request_id: UUID,
  timestamp: ISODateTime,
  processing_time_ms: z.number().nonnegative(),
  // Signal output
  signal: z.object({
    symbol: Symbol2,
    timeframe: Timeframe,
    decision: Decision,
    confidence: Confidence,
    model_version: z.string(),
    // Optional rationale
    rationale: z.array(z.string()).optional(),
    // Optional additional data
    metadata: z.record(z.any()).optional()
  }),
  // Model performance metrics
  metrics: z.object({
    feature_importance: z.record(z.number()).optional(),
    prediction_uncertainty: z.number().min(0).max(1).optional(),
    model_confidence: z.number().min(0).max(1).optional()
  }).optional(),
  // Error handling
  error: z.object({
    code: z.string(),
    message: z.string(),
    details: z.any().optional()
  }).optional()
}).strict();
var ConsensusInferenceRequest = z.object({
  // Request metadata
  request_id: UUID,
  timestamp: ISODateTime,
  // Market context
  symbol: Symbol2,
  timeframe: Timeframe,
  // Input signals to aggregate
  signals: z.array(z.object({
    model_id: z.string(),
    model_version: z.string(),
    decision: Decision,
    confidence: Confidence,
    weight: z.number().min(0).max(1).optional(),
    metadata: z.record(z.any()).optional()
  })).min(1).max(50),
  // Consensus configuration
  consensus_config: z.object({
    method: z.enum(["weighted_average", "majority_vote", "ensemble"]).optional(),
    min_confidence: z.number().min(0).max(1).optional(),
    require_agreement: z.boolean().optional()
  }).optional()
}).strict();
var ConsensusInferenceResponse = z.object({
  // Response metadata
  request_id: UUID,
  timestamp: ISODateTime,
  processing_time_ms: z.number().nonnegative(),
  // Consensus output
  consensus: z.object({
    symbol: Symbol2,
    timeframe: Timeframe,
    decision: Decision,
    confidence: Confidence,
    model_version: z.string(),
    // Consensus details
    contributing_models: z.array(z.object({
      model_id: z.string(),
      weight: z.number().min(0).max(1),
      contribution: z.number().min(-1).max(1)
    })),
    // Optional rationale
    rationale: z.array(z.string()).optional(),
    // Optional additional data
    metadata: z.record(z.any()).optional()
  }),
  // Consensus metrics
  metrics: z.object({
    agreement_score: z.number().min(0).max(1).optional(),
    diversity_index: z.number().min(0).max(1).optional(),
    confidence_interval: z.object({
      lower: z.number().min(0).max(1),
      upper: z.number().min(0).max(1)
    }).optional()
  }).optional(),
  // Error handling
  error: z.object({
    code: z.string(),
    message: z.string(),
    details: z.any().optional()
  }).optional()
}).strict();
var OptimizerRequest = z.object({
  // Request metadata
  request_id: UUID,
  timestamp: ISODateTime,
  // Optimization context
  symbols: z.array(Symbol2).min(1).max(100),
  timeframe: Timeframe,
  // Market data
  market_data: z.object({
    prices: z.record(z.number().positive()),
    volatilities: z.record(z.number().nonnegative()),
    correlations: z.record(z.record(z.number().min(-1).max(1)))
  }),
  // Optimization parameters
  optimization_config: z.object({
    objective: z.enum(["maximize_sharpe", "minimize_risk", "maximize_return"]),
    constraints: z.object({
      max_weight: z.number().min(0).max(1).optional(),
      min_weight: z.number().min(0).max(1).optional(),
      max_turnover: z.number().min(0).max(1).optional()
    }).optional(),
    risk_budget: z.number().min(0).max(1).optional()
  })
}).strict();
var OptimizerResponse = z.object({
  // Response metadata
  request_id: UUID,
  timestamp: ISODateTime,
  processing_time_ms: z.number().nonnegative(),
  // Optimization output
  portfolio: z.object({
    weights: z.record(z.number().min(0).max(1)),
    expected_return: z.number(),
    expected_volatility: z.number().nonnegative(),
    sharpe_ratio: z.number(),
    // Optional metrics
    metrics: z.object({
      diversification_ratio: z.number().optional(),
      max_drawdown: z.number().optional(),
      var_95: z.number().optional()
    }).optional()
  }),
  // Optimization details
  optimization_details: z.object({
    iterations: z.number().int().nonnegative(),
    convergence: z.boolean(),
    objective_value: z.number()
  }).optional(),
  // Error handling
  error: z.object({
    code: z.string(),
    message: z.string(),
    details: z.any().optional()
  }).optional()
}).strict();
var ISODateTime2 = z.string().datetime();
var UUID2 = z.string().uuid();
var Slug = z.string().regex(/^[a-z0-9-]+$/).min(1).max(50);
var Version = z.string().regex(/^\d+\.\d+\.\d+$/);
var URL = z.string().url();
var Email = z.string().email();
var CatalogModel = z.object({
  // Model identity
  id: UUID2,
  slug: Slug,
  name: z.string().min(1).max(100),
  description: z.string().max(1e3).optional(),
  // Model metadata
  vendor: z.object({
    id: z.string(),
    name: z.string(),
    email: Email.optional(),
    website: URL.optional()
  }),
  // Model details
  task: z.enum(["signal", "consensus", "optimization", "feature_engineering"]),
  domain: z.enum(["forex", "stocks", "crypto", "commodities", "multi_asset"]),
  timeframe: z.enum(["1m", "5m", "15m", "1h", "4h", "1d", "multi"]),
  // Performance metrics
  performance: z.object({
    sharpe_ratio: z.number().optional(),
    win_rate: z.number().min(0).max(1).optional(),
    max_drawdown: z.number().min(0).max(1).optional(),
    total_return: z.number().optional(),
    volatility: z.number().nonnegative().optional(),
    calmar_ratio: z.number().optional()
  }).optional(),
  // Model versions
  latest_version: Version,
  versions: z.array(z.object({
    version: Version,
    created_at: ISODateTime2,
    description: z.string().optional(),
    performance: z.record(z.number()).optional(),
    artifact_url: URL.optional()
  })),
  // Deployment status
  deployment_status: z.enum(["available", "deployed", "maintenance", "deprecated"]),
  active_deployments: z.number().int().nonnegative(),
  // Marketplace metadata
  tags: z.array(z.string()).max(10),
  license: z.enum(["MIT", "Apache-2.0", "GPL-3.0", "Commercial", "Custom"]),
  pricing: z.object({
    model: z.enum(["free", "per_inference", "subscription", "enterprise"]),
    cost_per_inference: z.number().nonnegative().optional(),
    monthly_cost: z.number().nonnegative().optional()
  }).optional(),
  // Timestamps
  created_at: ISODateTime2,
  updated_at: ISODateTime2,
  last_deployed_at: ISODateTime2.optional()
}).strict();
var ModelVersion = z.object({
  // Version identity
  model_id: UUID2,
  version: Version,
  // Version metadata
  description: z.string().max(1e3).optional(),
  changelog: z.string().max(2e3).optional(),
  // Artifacts
  artifacts: z.object({
    model_file: URL.optional(),
    config_file: URL.optional(),
    requirements: URL.optional(),
    docker_image: z.string().optional(),
    inference_script: URL.optional()
  }).optional(),
  // Performance metrics
  performance: z.object({
    backtest_results: z.record(z.number()).optional(),
    live_performance: z.record(z.number()).optional(),
    benchmark_scores: z.record(z.number()).optional()
  }).optional(),
  // Validation
  validation_status: z.enum(["pending", "passed", "failed", "skipped"]),
  validation_results: z.object({
    accuracy: z.number().min(0).max(1).optional(),
    latency_ms: z.number().nonnegative().optional(),
    memory_mb: z.number().nonnegative().optional(),
    cpu_usage: z.number().min(0).max(1).optional()
  }).optional(),
  // Timestamps
  created_at: ISODateTime2,
  validated_at: ISODateTime2.optional()
}).strict();
var Deployment = z.object({
  // Deployment identity
  id: UUID2,
  model_id: UUID2,
  model_version: Version,
  // Deployment metadata
  name: z.string().min(1).max(100),
  description: z.string().max(500).optional(),
  // Infrastructure details
  provider: z.enum(["runpod", "aws", "gcp", "azure", "local"]),
  region: z.string().optional(),
  instance_type: z.string().optional(),
  // Resource allocation
  resources: z.object({
    cpu_cores: z.number().int().positive(),
    memory_gb: z.number().positive(),
    gpu_type: z.string().optional(),
    gpu_count: z.number().int().nonnegative().optional()
  }),
  // Deployment configuration
  config: z.object({
    max_concurrent_requests: z.number().int().positive().optional(),
    timeout_ms: z.number().int().positive().optional(),
    auto_scaling: z.boolean().optional(),
    health_check_interval: z.number().int().positive().optional()
  }).optional(),
  // Status and health
  status: z.enum(["deploying", "running", "stopped", "error", "maintenance"]),
  health: z.enum(["healthy", "degraded", "unhealthy", "unknown"]),
  last_heartbeat: ISODateTime2.optional(),
  // Performance metrics
  metrics: z.object({
    requests_per_minute: z.number().nonnegative().optional(),
    average_latency_ms: z.number().nonnegative().optional(),
    error_rate: z.number().min(0).max(1).optional(),
    cpu_usage: z.number().min(0).max(1).optional(),
    memory_usage: z.number().min(0).max(1).optional()
  }).optional(),
  // Timestamps
  created_at: ISODateTime2,
  started_at: ISODateTime2.optional(),
  stopped_at: ISODateTime2.optional()
}).strict();
var Health = z.object({
  // Health identity
  deployment_id: UUID2,
  timestamp: ISODateTime2,
  // Overall health
  status: z.enum(["healthy", "degraded", "unhealthy", "unknown"]),
  // System metrics
  system: z.object({
    cpu_usage: z.number().min(0).max(1),
    memory_usage: z.number().min(0).max(1),
    disk_usage: z.number().min(0).max(1).optional(),
    gpu_usage: z.number().min(0).max(1).optional(),
    gpu_memory_usage: z.number().min(0).max(1).optional()
  }),
  // Application metrics
  application: z.object({
    requests_per_minute: z.number().nonnegative(),
    average_latency_ms: z.number().nonnegative(),
    error_rate: z.number().min(0).max(1),
    queue_depth: z.number().int().nonnegative().optional(),
    active_connections: z.number().int().nonnegative().optional()
  }),
  // Model-specific metrics
  model: z.object({
    inference_count: z.number().int().nonnegative().optional(),
    last_inference_at: ISODateTime2.optional(),
    model_loaded: z.boolean().optional(),
    prediction_accuracy: z.number().min(0).max(1).optional()
  }).optional(),
  // Health checks
  checks: z.array(z.object({
    name: z.string(),
    status: z.enum(["pass", "fail", "warn"]),
    message: z.string().optional(),
    duration_ms: z.number().nonnegative().optional()
  })).optional(),
  // Error information
  errors: z.array(z.object({
    code: z.string(),
    message: z.string(),
    timestamp: ISODateTime2,
    count: z.number().int().positive()
  })).optional()
}).strict();
var CatalogRequest = z.object({
  // Filtering
  task: z.enum(["signal", "consensus", "optimization", "feature_engineering"]).optional(),
  domain: z.enum(["forex", "stocks", "crypto", "commodities", "multi_asset"]).optional(),
  timeframe: z.enum(["1m", "5m", "15m", "1h", "4h", "1d", "multi"]).optional(),
  // Sorting
  sort_by: z.enum(["created_at", "updated_at", "sharpe_ratio", "win_rate", "name"]).optional(),
  sort_order: z.enum(["asc", "desc"]).optional(),
  // Pagination
  page: z.number().int().positive().optional(),
  limit: z.number().int().min(1).max(100).optional(),
  // Search
  search: z.string().max(100).optional(),
  tags: z.array(z.string()).max(10).optional()
}).strict();
var CatalogResponse = z.object({
  models: z.array(CatalogModel),
  pagination: z.object({
    page: z.number().int().positive(),
    limit: z.number().int().positive(),
    total: z.number().int().nonnegative(),
    pages: z.number().int().positive()
  }),
  filters: z.object({
    tasks: z.array(z.string()),
    domains: z.array(z.string()),
    timeframes: z.array(z.string()),
    tags: z.array(z.string())
  }).optional()
}).strict();
var ModelDetailRequest = z.object({
  model_id: UUID2.optional(),
  slug: Slug.optional()
}).refine((data) => data.model_id || data.slug, {
  message: "Either model_id or slug must be provided"
});
var ModelDetailResponse = z.object({
  model: CatalogModel,
  versions: z.array(ModelVersion),
  deployments: z.array(Deployment),
  health: z.array(Health).optional()
}).strict();

// src/index.ts
init_infra_write();

// src/helpers.ts
function withMarketplaceHeaders(options) {
  const headers = {
    "Authorization": `Bearer ${options.token}`,
    "X-Marketplace-Contracts-Version": options.contractsVersion,
    "Content-Type": "application/json"
  };
  if (options.idempotencyKey) {
    headers["X-Idempotency-Key"] = options.idempotencyKey;
  }
  if (options.vendorId) {
    headers["X-Vendor-ID"] = options.vendorId;
  }
  if (options.deploymentId) {
    headers["X-Deployment-ID"] = options.deploymentId;
  }
  return headers;
}
function validateMarketplaceHeaders(headers) {
  const errors = [];
  if (!headers["Authorization"] || !headers["Authorization"].startsWith("Bearer ")) {
    errors.push("Missing or invalid Authorization header");
  }
  if (!headers["X-Marketplace-Contracts-Version"]) {
    errors.push("Missing X-Marketplace-Contracts-Version header");
  } else {
    const versionRegex = /^\d+\.\d+\.\d+$/;
    if (!versionRegex.test(headers["X-Marketplace-Contracts-Version"])) {
      errors.push("Invalid X-Marketplace-Contracts-Version format");
    }
  }
  if (headers["Content-Type"] !== "application/json") {
    errors.push("Content-Type must be application/json");
  }
  return {
    valid: errors.length === 0,
    errors
  };
}
function makeIdempotencyKey(symbol, timeframe, timestamp) {
  const slot = Math.floor((timestamp || Date.now()) / 5e3);
  return `${symbol}:${timeframe}:${slot}`;
}
function parseIdempotencyKey(key) {
  const parts = key.split(":");
  if (parts.length !== 3) {
    return null;
  }
  const [symbol, timeframe, slotStr] = parts;
  const slot = parseInt(slotStr, 10);
  if (isNaN(slot)) {
    return null;
  }
  return { symbol, timeframe, slot };
}
function validateIdempotencySlot(slot, tolerance = 1) {
  const currentSlot = Math.floor(Date.now() / 5e3);
  const diff = Math.abs(slot - currentSlot);
  return diff <= tolerance;
}
function validateSignalWrite(data) {
  try {
    const { SignalWrite: SignalWrite2 } = (init_infra_write(), __toCommonJS(infra_write_exports));
    const result = SignalWrite2.safeParse(data);
    if (result.success) {
      return { valid: true, errors: [], data: result.data };
    } else {
      return {
        valid: false,
        errors: result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`)
      };
    }
  } catch (error) {
    return {
      valid: false,
      errors: [`Validation error: ${error instanceof Error ? error.message : "Unknown error"}`]
    };
  }
}
function validateConsensusWrite(data) {
  try {
    const { ConsensusWrite: ConsensusWrite2 } = (init_infra_write(), __toCommonJS(infra_write_exports));
    const result = ConsensusWrite2.safeParse(data);
    if (result.success) {
      return { valid: true, errors: [], data: result.data };
    } else {
      return {
        valid: false,
        errors: result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`)
      };
    }
  } catch (error) {
    return {
      valid: false,
      errors: [`Validation error: ${error instanceof Error ? error.message : "Unknown error"}`]
    };
  }
}
function generateRequestId() {
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
    const r = Math.random() * 16 | 0;
    const v = c === "x" ? r : r & 3 | 8;
    return v.toString(16);
  });
}
function formatTimestamp(timestamp) {
  return new Date(timestamp || Date.now()).toISOString();
}
function calculateConfidenceInterval(confidence, margin = 0.1) {
  const lower = Math.max(0, confidence - margin);
  const upper = Math.min(1, confidence + margin);
  return { lower, upper };
}
function aggregateSignals(signals) {
  if (signals.length === 0) {
    return { decision: "UNKNOWN", confidence: 0, contributing_count: 0 };
  }
  const decisionValues = { "SELL": -1, "HOLD": 0, "BUY": 1, "UNKNOWN": 0 };
  let weightedSum = 0;
  let totalWeight = 0;
  let confidenceSum = 0;
  let contributingCount = 0;
  for (const signal of signals) {
    const weight = signal.weight || 1;
    const decisionValue = decisionValues[signal.decision];
    weightedSum += decisionValue * weight;
    totalWeight += weight;
    confidenceSum += signal.confidence * weight;
    contributingCount++;
  }
  const averageDecision = weightedSum / totalWeight;
  const averageConfidence = confidenceSum / totalWeight;
  let decision;
  if (averageDecision > 0.3) {
    decision = "BUY";
  } else if (averageDecision < -0.3) {
    decision = "SELL";
  } else {
    decision = "HOLD";
  }
  return {
    decision,
    confidence: Math.min(1, Math.max(0, averageConfidence)),
    contributing_count: contributingCount
  };
}

// src/index.ts
var MARKETPLACE_CONTRACTS_VERSION = "0.1.0";
var MARKETPLACE_CONTRACTS_FINGERPRINT = "0.1.0:marketplace-contracts-initial-release";
var PodIOSchemas = {
  SignalInferenceRequest,
  SignalInferenceResponse,
  ConsensusInferenceRequest,
  ConsensusInferenceResponse,
  OptimizerRequest,
  OptimizerResponse
};
var MarketplaceSchemas = {
  CatalogModel,
  ModelVersion,
  Deployment,
  Health,
  CatalogRequest,
  CatalogResponse,
  ModelDetailRequest,
  ModelDetailResponse
};
var InfraWriteSchemas = {
  SignalWrite,
  ConsensusWrite,
  BatchSignalWrite,
  BatchConsensusWrite,
  SignalWriteRequest,
  ConsensusWriteRequest,
  WriteResponse,
  MarketplaceHeaders
};
var Helpers = {
  withMarketplaceHeaders,
  validateMarketplaceHeaders,
  makeIdempotencyKey,
  parseIdempotencyKey,
  validateIdempotencySlot,
  validateSignalWrite,
  validateConsensusWrite,
  generateRequestId,
  formatTimestamp,
  calculateConfidenceInterval,
  aggregateSignals
};
var index_default = {
  version: MARKETPLACE_CONTRACTS_VERSION,
  fingerprint: MARKETPLACE_CONTRACTS_FINGERPRINT,
  schemas: {
    podIO: PodIOSchemas,
    marketplace: MarketplaceSchemas,
    infraWrite: InfraWriteSchemas
  },
  helpers: Helpers
};

export { Helpers, InfraWriteSchemas, MARKETPLACE_CONTRACTS_FINGERPRINT, MARKETPLACE_CONTRACTS_VERSION, MarketplaceSchemas, PodIOSchemas, index_default as default };
//# sourceMappingURL=index.mjs.map
//# sourceMappingURL=index.mjs.map