@antseed/node 0.1.0 → 0.1.1

package/src/discovery/metadata-codec.ts

@@ -1,453 +0,0 @@
-import type { PeerMetadata } from "./peer-metadata.js";
-import type { PeerOffering } from "../types/capability.js";
-import { hexToBytes, bytesToHex } from "../utils/hex.js";
-import { toPeerId } from "../types/peer.js";
-
-/**
- * Encode metadata into binary format:
- * [version:1][peerId:32][regionLen:1][region:N][timestamp:8 BigUint64][providerCount:1]
- * for each provider:
- *   [providerLen:1][provider:N][modelCount:1][models...]
- *   [defaultInputPrice:4][defaultOutputPrice:4]
- *   [modelPricingCount:1][modelPricingEntries...]
- *   [maxConcurrency:2][currentLoad:2]
- * modelPricingEntry: [modelLen:1][model:N][inputPrice:4][outputPrice:4]
- * [signature:64]
- */
-export function encodeMetadata(metadata: PeerMetadata): Uint8Array {
-  const bodyBytes = encodeBody(metadata);
-  const signatureBytes = hexToBytes(metadata.signature);
-
-  const result = new Uint8Array(bodyBytes.length + signatureBytes.length);
-  result.set(bodyBytes, 0);
-  result.set(signatureBytes, bodyBytes.length);
-  return result;
-}
-
-/**
- * Encode metadata without signature, for signing purposes.
- */
-export function encodeMetadataForSigning(metadata: PeerMetadata): Uint8Array {
-  return encodeBody(metadata);
-}
-
-function encodeBody(metadata: PeerMetadata): Uint8Array {
-  const parts: Uint8Array[] = [];
-
-  // version: 1 byte
-  parts.push(new Uint8Array([metadata.version]));
-
-  // peerId: 32 bytes
-  parts.push(hexToBytes(metadata.peerId));
-
-  // region: length-prefixed
-  const regionBytes = new TextEncoder().encode(metadata.region);
-  parts.push(new Uint8Array([regionBytes.length]));
-  parts.push(regionBytes);
-
-  // timestamp: 8 bytes BigUint64
-  const timestampBuf = new ArrayBuffer(8);
-  const timestampView = new DataView(timestampBuf);
-  timestampView.setBigUint64(0, BigInt(metadata.timestamp), false);
-  parts.push(new Uint8Array(timestampBuf));
-
-  // providerCount: 1 byte
-  parts.push(new Uint8Array([metadata.providers.length]));
-
-  // each provider
-  for (const p of metadata.providers) {
-    const providerNameBytes = new TextEncoder().encode(p.provider);
-    parts.push(new Uint8Array([providerNameBytes.length]));
-    parts.push(providerNameBytes);
-
-    // modelCount: 1 byte
-    parts.push(new Uint8Array([p.models.length]));
-
-    // each model: length-prefixed
-    for (const model of p.models) {
-      const modelBytes = new TextEncoder().encode(model);
-      parts.push(new Uint8Array([modelBytes.length]));
-      parts.push(modelBytes);
-    }
-
-    // default input price: 4 bytes (float32)
-    const inputPriceBuf = new ArrayBuffer(4);
-    new DataView(inputPriceBuf).setFloat32(0, p.defaultPricing.inputUsdPerMillion, false);
-    parts.push(new Uint8Array(inputPriceBuf));
-
-    // default output price: 4 bytes (float32)
-    const outputPriceBuf = new ArrayBuffer(4);
-    new DataView(outputPriceBuf).setFloat32(0, p.defaultPricing.outputUsdPerMillion, false);
-    parts.push(new Uint8Array(outputPriceBuf));
-
-    // modelPricing entries
-    const modelPricingEntries = Object.entries(p.modelPricing ?? {}).sort(([a], [b]) =>
-      a.localeCompare(b),
-    );
-    parts.push(new Uint8Array([modelPricingEntries.length]));
-    for (const [modelName, pricing] of modelPricingEntries) {
-      const modelNameBytes = new TextEncoder().encode(modelName);
-      parts.push(new Uint8Array([modelNameBytes.length]));
-      parts.push(modelNameBytes);
-
-      const modelInputBuf = new ArrayBuffer(4);
-      new DataView(modelInputBuf).setFloat32(0, pricing.inputUsdPerMillion, false);
-      parts.push(new Uint8Array(modelInputBuf));
-
-      const modelOutputBuf = new ArrayBuffer(4);
-      new DataView(modelOutputBuf).setFloat32(0, pricing.outputUsdPerMillion, false);
-      parts.push(new Uint8Array(modelOutputBuf));
-    }
-
-    // maxConcurrency: 2 bytes (uint16)
-    const maxConcBuf = new ArrayBuffer(2);
-    new DataView(maxConcBuf).setUint16(0, p.maxConcurrency, false);
-    parts.push(new Uint8Array(maxConcBuf));
-
-    // currentLoad: 2 bytes (uint16)
-    const loadBuf = new ArrayBuffer(2);
-    new DataView(loadBuf).setUint16(0, p.currentLoad, false);
-    parts.push(new Uint8Array(loadBuf));
-  }
-
-  // offerings
-  const offerings = metadata.offerings ?? [];
-  const offeringCountBuf = new ArrayBuffer(2);
-  new DataView(offeringCountBuf).setUint16(0, offerings.length, false);
-  parts.push(new Uint8Array(offeringCountBuf));
-
-  const PRICING_UNIT_MAP: Record<string, number> = { token: 0, request: 1, minute: 2, task: 3 };
-
-  for (const o of offerings) {
-    // capability: length-prefixed (1 byte len)
-    const capBytes = new TextEncoder().encode(o.capability);
-    parts.push(new Uint8Array([capBytes.length]));
-    parts.push(capBytes);
-
-    // name: length-prefixed (1 byte len)
-    const nameBytes = new TextEncoder().encode(o.name);
-    parts.push(new Uint8Array([nameBytes.length]));
-    parts.push(nameBytes);
-
-    // description: length-prefixed (2 byte uint16 len)
-    const descBytes = new TextEncoder().encode(o.description);
-    const descLenBuf = new ArrayBuffer(2);
-    new DataView(descLenBuf).setUint16(0, descBytes.length, false);
-    parts.push(new Uint8Array(descLenBuf));
-    parts.push(descBytes);
-
-    // pricingUnit: 1 byte
-    parts.push(new Uint8Array([PRICING_UNIT_MAP[o.pricing.unit] ?? 0]));
-
-    // pricePerUnit: 4 bytes float32
-    const priceBuf = new ArrayBuffer(4);
-    new DataView(priceBuf).setFloat32(0, o.pricing.pricePerUnit, false);
-    parts.push(new Uint8Array(priceBuf));
-
-    // modelCount: 1 byte, then each model
-    const models = o.models ?? [];
-    parts.push(new Uint8Array([models.length]));
-    for (const model of models) {
-      const modelBytes = new TextEncoder().encode(model);
-      parts.push(new Uint8Array([modelBytes.length]));
-      parts.push(modelBytes);
-    }
-  }
-
-  // EVM address: 1 flag byte + 20 address bytes if present
-  if (metadata.evmAddress) {
-    parts.push(new Uint8Array([1])); // flag: present
-    // Strip 0x prefix if present, then decode 20 bytes
-    const addrHex = metadata.evmAddress.startsWith('0x')
-      ? metadata.evmAddress.slice(2)
-      : metadata.evmAddress;
-    parts.push(hexToBytes(addrHex.toLowerCase().padStart(40, '0')));
-  } else {
-    parts.push(new Uint8Array([0])); // flag: absent
-  }
-
-  // On-chain reputation: 1 flag byte + 10 data bytes (1 reputation + 4 sessionCount + 4 disputeCount + 1 reserved)
-  if (metadata.onChainReputation !== undefined) {
-    parts.push(new Uint8Array([1])); // flag: present
-    const repBuf = new ArrayBuffer(10);
-    const repView = new DataView(repBuf);
-    repView.setUint8(0, Math.min(255, Math.max(0, metadata.onChainReputation)));
-    repView.setUint32(1, metadata.onChainSessionCount ?? 0, false);
-    repView.setUint32(5, metadata.onChainDisputeCount ?? 0, false);
-    repView.setUint8(9, 0); // reserved
-    parts.push(new Uint8Array(repBuf));
-  } else {
-    parts.push(new Uint8Array([0])); // flag: absent
-  }
-
-  // Combine all parts
-  const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const part of parts) {
-    result.set(part, offset);
-    offset += part.length;
-  }
-  return result;
-}
-
-/**
- * Decode binary metadata back into PeerMetadata.
- */
-export function decodeMetadata(data: Uint8Array): PeerMetadata {
-  function checkBounds(offset: number, needed: number, total: number): void {
-    if (offset + needed > total) throw new Error('Truncated metadata buffer');
-  }
-
-  let offset = 0;
-
-  // version: 1 byte
-  checkBounds(offset, 1, data.length);
-  const version = data[offset]!;
-  offset += 1;
-
-  // peerId: 32 bytes
-  checkBounds(offset, 32, data.length);
-  const peerIdBytes = data.slice(offset, offset + 32);
-  const peerId = bytesToHex(peerIdBytes);
-  offset += 32;
-
-  // region: length-prefixed
-  checkBounds(offset, 1, data.length);
-  const regionLen = data[offset]!;
-  offset += 1;
-  checkBounds(offset, regionLen, data.length);
-  const region = new TextDecoder().decode(data.slice(offset, offset + regionLen));
-  offset += regionLen;
-
-  // timestamp: 8 bytes BigUint64
-  checkBounds(offset, 8, data.length);
-  const timestampView = new DataView(data.buffer, data.byteOffset + offset, 8);
-  const timestamp = Number(timestampView.getBigUint64(0, false));
-  offset += 8;
-
-  // providerCount: 1 byte
-  checkBounds(offset, 1, data.length);
-  const providerCount = data[offset]!;
-  offset += 1;
-
-  const providers = [];
-  for (let i = 0; i < providerCount; i++) {
-    // provider name: length-prefixed
-    checkBounds(offset, 1, data.length);
-    const providerLen = data[offset]!;
-    offset += 1;
-    checkBounds(offset, providerLen, data.length);
-    const provider = new TextDecoder().decode(data.slice(offset, offset + providerLen));
-    offset += providerLen;
-
-    // modelCount: 1 byte
-    checkBounds(offset, 1, data.length);
-    const modelCount = data[offset]!;
-    offset += 1;
-
-    const models: string[] = [];
-    for (let j = 0; j < modelCount; j++) {
-      checkBounds(offset, 1, data.length);
-      const modelLen = data[offset]!;
-      offset += 1;
-      checkBounds(offset, modelLen, data.length);
-      const model = new TextDecoder().decode(data.slice(offset, offset + modelLen));
-      offset += modelLen;
-      models.push(model);
-    }
-
-    // default input price: 4 bytes float32
-    checkBounds(offset, 4, data.length);
-    const inputPriceView = new DataView(data.buffer, data.byteOffset + offset, 4);
-    const defaultInputUsdPerMillion = inputPriceView.getFloat32(0, false);
-    offset += 4;
-
-    // default output price: 4 bytes float32
-    checkBounds(offset, 4, data.length);
-    const outputPriceView = new DataView(data.buffer, data.byteOffset + offset, 4);
-    const defaultOutputUsdPerMillion = outputPriceView.getFloat32(0, false);
-    offset += 4;
-
-    // modelPricing entries
-    checkBounds(offset, 1, data.length);
-    const modelPricingCount = data[offset]!;
-    offset += 1;
-
-    const modelPricing: Record<string, { inputUsdPerMillion: number; outputUsdPerMillion: number }> = {};
-    for (let j = 0; j < modelPricingCount; j++) {
-      checkBounds(offset, 1, data.length);
-      const pricedModelLen = data[offset]!;
-      offset += 1;
-      checkBounds(offset, pricedModelLen, data.length);
-      const pricedModelName = new TextDecoder().decode(data.slice(offset, offset + pricedModelLen));
-      offset += pricedModelLen;
-
-      checkBounds(offset, 4, data.length);
-      const pricedInputView = new DataView(data.buffer, data.byteOffset + offset, 4);
-      const inputUsdPerMillion = pricedInputView.getFloat32(0, false);
-      offset += 4;
-
-      checkBounds(offset, 4, data.length);
-      const pricedOutputView = new DataView(data.buffer, data.byteOffset + offset, 4);
-      const outputUsdPerMillion = pricedOutputView.getFloat32(0, false);
-      offset += 4;
-
-      modelPricing[pricedModelName] = {
-        inputUsdPerMillion,
-        outputUsdPerMillion,
-      };
-    }
-
-    // maxConcurrency: 2 bytes uint16
-    checkBounds(offset, 2, data.length);
-    const maxConcView = new DataView(data.buffer, data.byteOffset + offset, 2);
-    const maxConcurrency = maxConcView.getUint16(0, false);
-    offset += 2;
-
-    // currentLoad: 2 bytes uint16
-    checkBounds(offset, 2, data.length);
-    const loadView = new DataView(data.buffer, data.byteOffset + offset, 2);
-    const currentLoad = loadView.getUint16(0, false);
-    offset += 2;
-
-    providers.push({
-      provider,
-      models,
-      defaultPricing: {
-        inputUsdPerMillion: defaultInputUsdPerMillion,
-        outputUsdPerMillion: defaultOutputUsdPerMillion,
-      },
-      ...(modelPricingCount > 0 ? { modelPricing } : {}),
-      maxConcurrency,
-      currentLoad,
-    });
-  }
-
-  // offerings (optional — present if there are remaining bytes before the 64-byte signature)
-  const PRICING_UNIT_REVERSE: Array<'token' | 'request' | 'minute' | 'task'> = ['token', 'request', 'minute', 'task'];
-  let offerings: PeerOffering[] | undefined;
-
-  const remainingBeforeSignature = data.length - offset - 64;
-  if (remainingBeforeSignature >= 2) {
-    offerings = [];
-    checkBounds(offset, 2, data.length - 64);
-    const offeringCountView = new DataView(data.buffer, data.byteOffset + offset, 2);
-    const offeringCount = offeringCountView.getUint16(0, false);
-    offset += 2;
-
-    for (let i = 0; i < offeringCount; i++) {
-      // capability
-      checkBounds(offset, 1, data.length - 64);
-      const capLen = data[offset]!;
-      offset += 1;
-      checkBounds(offset, capLen, data.length - 64);
-      const capability = new TextDecoder().decode(data.slice(offset, offset + capLen));
-      offset += capLen;
-
-      // name
-      checkBounds(offset, 1, data.length - 64);
-      const nameLen = data[offset]!;
-      offset += 1;
-      checkBounds(offset, nameLen, data.length - 64);
-      const name = new TextDecoder().decode(data.slice(offset, offset + nameLen));
-      offset += nameLen;
-
-      // description (uint16 length)
-      checkBounds(offset, 2, data.length - 64);
-      const descLenView = new DataView(data.buffer, data.byteOffset + offset, 2);
-      const descLen = descLenView.getUint16(0, false);
-      offset += 2;
-      checkBounds(offset, descLen, data.length - 64);
-      const description = new TextDecoder().decode(data.slice(offset, offset + descLen));
-      offset += descLen;
-
-      // pricingUnit: 1 byte
-      checkBounds(offset, 1, data.length - 64);
-      const pricingUnitIdx = data[offset]!;
-      offset += 1;
-      const unit = PRICING_UNIT_REVERSE[pricingUnitIdx] ?? 'token';
-
-      // pricePerUnit: 4 bytes float32
-      checkBounds(offset, 4, data.length - 64);
-      const priceView = new DataView(data.buffer, data.byteOffset + offset, 4);
-      const pricePerUnit = priceView.getFloat32(0, false);
-      offset += 4;
-
-      // models
-      checkBounds(offset, 1, data.length - 64);
-      const modelCount = data[offset]!;
-      offset += 1;
-      const models: string[] = [];
-      for (let j = 0; j < modelCount; j++) {
-        checkBounds(offset, 1, data.length - 64);
-        const modelLen = data[offset]!;
-        offset += 1;
-        checkBounds(offset, modelLen, data.length - 64);
-        const model = new TextDecoder().decode(data.slice(offset, offset + modelLen));
-        offset += modelLen;
-        models.push(model);
-      }
-
-      offerings.push({
-        capability: capability as PeerOffering['capability'],
-        name,
-        description,
-        models: models.length > 0 ? models : undefined,
-        pricing: { unit, pricePerUnit, currency: 'USD' },
-      });
-    }
-  }
-
-  // Optional EVM address (flag + 20 bytes) — present if there are enough remaining bytes before signature
-  let evmAddress: string | undefined;
-  const remainingBeforeEvmSig = data.length - offset - 64;
-  if (remainingBeforeEvmSig >= 1) {
-    const evmFlag = data[offset]!;
-    offset += 1;
-    if (evmFlag === 1) {
-      checkBounds(offset, 20, data.length - 64);
-      const addrBytes = data.slice(offset, offset + 20);
-      evmAddress = '0x' + bytesToHex(addrBytes);
-      offset += 20;
-    }
-  }
-
-  // Optional on-chain reputation (flag + 10 bytes)
-  let onChainReputation: number | undefined;
-  let onChainSessionCount: number | undefined;
-  let onChainDisputeCount: number | undefined;
-  const remainingBeforeRepSig = data.length - offset - 64;
-  if (remainingBeforeRepSig >= 1) {
-    const repFlag = data[offset]!;
-    offset += 1;
-    if (repFlag === 1) {
-      checkBounds(offset, 10, data.length - 64);
-      const repView = new DataView(data.buffer, data.byteOffset + offset, 10);
-      onChainReputation = repView.getUint8(0);
-      onChainSessionCount = repView.getUint32(1, false);
-      onChainDisputeCount = repView.getUint32(5, false);
-      // byte 9 is reserved
-      offset += 10;
-    }
-  }
-
-  // signature: 64 bytes
-  checkBounds(offset, 64, data.length);
-  const signatureBytes = data.slice(offset, offset + 64);
-  const signature = bytesToHex(signatureBytes);
-
-  return {
-    peerId: toPeerId(peerId),
-    version,
-    providers,
-    ...(offerings && offerings.length > 0 ? { offerings } : {}),
-    ...(evmAddress !== undefined ? { evmAddress } : {}),
-    ...(onChainReputation !== undefined ? { onChainReputation } : {}),
-    ...(onChainSessionCount !== undefined ? { onChainSessionCount } : {}),
-    ...(onChainDisputeCount !== undefined ? { onChainDisputeCount } : {}),
-    region,
-    timestamp,
-    signature,
-  };
-}

package/src/discovery/metadata-resolver.ts

@@ -1,7 +0,0 @@
-import type { PeerMetadata } from "./peer-metadata.js";
-
-export type PeerEndpoint = { host: string; port: number };
-
-export interface MetadataResolver {
-  resolve(peer: PeerEndpoint): Promise<PeerMetadata | null>;
-}

package/src/discovery/metadata-server.ts

@@ -1,73 +0,0 @@
-import { createServer, type Server, type IncomingMessage, type ServerResponse } from 'node:http';
-import type { PeerMetadata } from './peer-metadata.js';
-
-export interface MetadataServerConfig {
-  port: number;
-  host?: string;
-  getMetadata: () => PeerMetadata | null;
-}
-
-/** @deprecated Standalone MetadataServer is unused; ConnectionManager._serveHttpMetadata is preferred. */
-export class MetadataServer {
-  private readonly _config: MetadataServerConfig;
-  private _server: Server | null = null;
-
-  constructor(config: MetadataServerConfig) {
-    this._config = config;
-  }
-
-  async start(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this._server = createServer((req: IncomingMessage, res: ServerResponse) => {
-        if (req.method !== 'GET') {
-          res.writeHead(405, { 'content-type': 'application/json' });
-          res.end(JSON.stringify({ error: 'method not allowed' }));
-          return;
-        }
-
-        if (req.url !== '/metadata') {
-          res.writeHead(404, { 'content-type': 'application/json' });
-          res.end(JSON.stringify({ error: 'not found' }));
-          return;
-        }
-
-        const metadata = this._config.getMetadata();
-        if (!metadata) {
-          res.writeHead(503, { 'content-type': 'application/json' });
-          res.end(JSON.stringify({ error: 'metadata not available' }));
-          return;
-        }
-
-        res.writeHead(200, { 'content-type': 'application/json' });
-        res.end(JSON.stringify(metadata));
-      });
-
-      this._server.on('error', reject);
-      this._server.listen(this._config.port, this._config.host ?? '0.0.0.0', () => {
-        resolve();
-      });
-    });
-  }
-
-  async stop(): Promise<void> {
-    return new Promise((resolve) => {
-      if (!this._server) {
-        resolve();
-        return;
-      }
-      this._server.close(() => {
-        this._server = null;
-        resolve();
-      });
-    });
-  }
-
-  getPort(): number {
-    if (!this._server) return this._config.port;
-    const addr = this._server.address();
-    if (addr && typeof addr !== 'string') {
-      return addr.port;
-    }
-    return this._config.port;
-  }
-}

package/src/discovery/metadata-validator.ts

@@ -1,172 +0,0 @@
-import type { PeerMetadata } from "./peer-metadata.js";
-import { METADATA_VERSION } from "./peer-metadata.js";
-import { encodeMetadata } from "./metadata-codec.js";
-
-export const MAX_METADATA_SIZE = 1000;
-export const MAX_PROVIDERS = 10;
-export const MAX_MODELS_PER_PROVIDER = 20;
-export const MAX_MODEL_NAME_LENGTH = 64;
-export const MAX_REGION_LENGTH = 32;
-
-export interface ValidationError {
-  field: string;
-  message: string;
-}
-
-export function validateMetadata(metadata: PeerMetadata): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  // version
-  if (metadata.version !== METADATA_VERSION) {
-    errors.push({
-      field: "version",
-      message: `Expected version ${METADATA_VERSION}, got ${metadata.version}`,
-    });
-  }
-
-  // peerId length (64 hex chars = 32 bytes)
-  if (!/^[0-9a-f]{64}$/.test(metadata.peerId)) {
-    errors.push({
-      field: "peerId",
-      message: "PeerId must be exactly 64 lowercase hex characters",
-    });
-  }
-
-  // region
-  if (!metadata.region || metadata.region.length === 0) {
-    errors.push({
-      field: "region",
-      message: "Region must not be empty",
-    });
-  } else if (metadata.region.length > MAX_REGION_LENGTH) {
-    errors.push({
-      field: "region",
-      message: `Region length ${metadata.region.length} exceeds max ${MAX_REGION_LENGTH}`,
-    });
-  }
-
-  // timestamp
-  if (metadata.timestamp <= 0 || !Number.isFinite(metadata.timestamp)) {
-    errors.push({
-      field: "timestamp",
-      message: "Timestamp must be a positive finite number",
-    });
-  }
-
-  // providers count
-  if (metadata.providers.length === 0) {
-    errors.push({
-      field: "providers",
-      message: "Must have at least one provider",
-    });
-  } else if (metadata.providers.length > MAX_PROVIDERS) {
-    errors.push({
-      field: "providers",
-      message: `Provider count ${metadata.providers.length} exceeds max ${MAX_PROVIDERS}`,
-    });
-  }
-
-  // each provider
-  for (let i = 0; i < metadata.providers.length; i++) {
-    const p = metadata.providers[i]!;
-
-    // models count
-    if (p.models.length > MAX_MODELS_PER_PROVIDER) {
-      errors.push({
-        field: `providers[${i}].models`,
-        message: `Model count ${p.models.length} exceeds max ${MAX_MODELS_PER_PROVIDER}`,
-      });
-    }
-
-    // model name length
-    for (let j = 0; j < p.models.length; j++) {
-      const model = p.models[j]!;
-      if (model.length > MAX_MODEL_NAME_LENGTH) {
-        errors.push({
-          field: `providers[${i}].models[${j}]`,
-          message: `Model name length ${model.length} exceeds max ${MAX_MODEL_NAME_LENGTH}`,
-        });
-      }
-    }
-
-    // default pricing
-    if (!Number.isFinite(p.defaultPricing?.inputUsdPerMillion) || p.defaultPricing.inputUsdPerMillion < 0) {
-      errors.push({
-        field: `providers[${i}].defaultPricing.inputUsdPerMillion`,
-        message: "Default input price must be a non-negative finite number",
-      });
-    }
-    if (!Number.isFinite(p.defaultPricing?.outputUsdPerMillion) || p.defaultPricing.outputUsdPerMillion < 0) {
-      errors.push({
-        field: `providers[${i}].defaultPricing.outputUsdPerMillion`,
-        message: "Default output price must be a non-negative finite number",
-      });
-    }
-
-    // model pricing (optional)
-    if (p.modelPricing !== undefined) {
-      for (const [modelName, modelPricing] of Object.entries(p.modelPricing)) {
-        if (!modelPricing || !Number.isFinite(modelPricing.inputUsdPerMillion) || modelPricing.inputUsdPerMillion < 0) {
-          errors.push({
-            field: `providers[${i}].modelPricing.${modelName}.inputUsdPerMillion`,
-            message: "Model input price must be a non-negative finite number",
-          });
-        }
-        if (!modelPricing || !Number.isFinite(modelPricing.outputUsdPerMillion) || modelPricing.outputUsdPerMillion < 0) {
-          errors.push({
-            field: `providers[${i}].modelPricing.${modelName}.outputUsdPerMillion`,
-            message: "Model output price must be a non-negative finite number",
-          });
-        }
-      }
-    }
-
-    // concurrency
-    if (p.maxConcurrency < 1) {
-      errors.push({
-        field: `providers[${i}].maxConcurrency`,
-        message: "Max concurrency must be at least 1",
-      });
-    }
-
-    // currentLoad
-    if (p.currentLoad < 0) {
-      errors.push({
-        field: `providers[${i}].currentLoad`,
-        message: "Current load must be non-negative",
-      });
-    }
-    if (p.currentLoad > p.maxConcurrency) {
-      errors.push({
-        field: `providers[${i}].currentLoad`,
-        message: "Current load must not exceed max concurrency",
-      });
-    }
-  }
-
-  // signature length (128 hex chars = 64 bytes)
-  if (!/^[0-9a-f]{128}$/.test(metadata.signature)) {
-    errors.push({
-      field: "signature",
-      message: "Signature must be exactly 128 lowercase hex characters (64 bytes)",
-    });
-  }
-
-  // encoded size
-  try {
-    const encoded = encodeMetadata(metadata);
-    if (encoded.length > MAX_METADATA_SIZE) {
-      errors.push({
-        field: "encoded",
-        message: `Encoded size ${encoded.length} exceeds max ${MAX_METADATA_SIZE}`,
-      });
-    }
-  } catch {
-    errors.push({
-      field: "encoded",
-      message: "Failed to encode metadata for size check",
-    });
-  }
-
-  return errors;
-}