@antseed/node 0.1.0 → 0.1.2

package/tests/metadata-codec.test.ts

@@ -1,165 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { encodeMetadata, decodeMetadata, encodeMetadataForSigning } from '../src/discovery/metadata-codec.js';
-import type { PeerMetadata } from '../src/discovery/peer-metadata.js';
-
-function makeMetadata(overrides?: Partial<PeerMetadata>): PeerMetadata {
-  return {
-    peerId: 'a'.repeat(64) as any,
-    version: 2,
-    providers: [
-      {
-        provider: 'anthropic',
-        models: ['claude-3-opus', 'claude-3-sonnet'],
-        defaultPricing: {
-          inputUsdPerMillion: 15,
-          outputUsdPerMillion: 75,
-        },
-        modelPricing: {
-          'claude-3-opus': {
-            inputUsdPerMillion: 18,
-            outputUsdPerMillion: 90,
-          },
-        },
-        maxConcurrency: 10,
-        currentLoad: 3,
-      },
-    ],
-    region: 'us-east-1',
-    timestamp: 1700000000000,
-    signature: 'b'.repeat(128),
-    ...overrides,
-  };
-}
-
-describe('encodeMetadata / decodeMetadata', () => {
-  it('should round-trip a basic metadata object', () => {
-    const original = makeMetadata();
-    const encoded = encodeMetadata(original);
-    const decoded = decodeMetadata(encoded);
-
-    expect(decoded.version).toBe(original.version);
-    expect(decoded.peerId).toBe(original.peerId);
-    expect(decoded.region).toBe(original.region);
-    expect(decoded.timestamp).toBe(original.timestamp);
-    expect(decoded.signature).toBe(original.signature);
-    expect(decoded.providers).toHaveLength(1);
-    expect(decoded.providers[0]!.provider).toBe('anthropic');
-    expect(decoded.providers[0]!.models).toEqual(['claude-3-opus', 'claude-3-sonnet']);
-    expect(decoded.providers[0]!.maxConcurrency).toBe(10);
-    expect(decoded.providers[0]!.currentLoad).toBe(3);
-  });
-
-  it('should handle float32 precision for prices', () => {
-    const original = makeMetadata();
-    const encoded = encodeMetadata(original);
-    const decoded = decodeMetadata(encoded);
-    // Float32 has limited precision — allow small delta
-    expect(decoded.providers[0]!.defaultPricing.inputUsdPerMillion).toBeCloseTo(15, 3);
-    expect(decoded.providers[0]!.defaultPricing.outputUsdPerMillion).toBeCloseTo(75, 3);
-    expect(decoded.providers[0]!.modelPricing?.['claude-3-opus']?.inputUsdPerMillion).toBeCloseTo(18, 3);
-    expect(decoded.providers[0]!.modelPricing?.['claude-3-opus']?.outputUsdPerMillion).toBeCloseTo(90, 3);
-  });
-
-  it('should round-trip multiple providers', () => {
-    const original = makeMetadata({
-      providers: [
-        {
-          provider: 'openai',
-          models: ['gpt-4'],
-          defaultPricing: {
-            inputUsdPerMillion: 10,
-            outputUsdPerMillion: 30,
-          },
-          maxConcurrency: 5,
-          currentLoad: 0,
-        },
-        {
-          provider: 'anthropic',
-          models: ['claude-3-haiku'],
-          defaultPricing: {
-            inputUsdPerMillion: 1,
-            outputUsdPerMillion: 5,
-          },
-          modelPricing: {
-            'claude-3-haiku': {
-              inputUsdPerMillion: 0.9,
-              outputUsdPerMillion: 4.5,
-            },
-          },
-          maxConcurrency: 20,
-          currentLoad: 10,
-        },
-      ],
-    });
-    const decoded = decodeMetadata(encodeMetadata(original));
-    expect(decoded.providers).toHaveLength(2);
-    expect(decoded.providers[0]!.provider).toBe('openai');
-    expect(decoded.providers[1]!.provider).toBe('anthropic');
-  });
-
-  it('should round-trip zero providers', () => {
-    const original = makeMetadata({ providers: [] });
-    const decoded = decodeMetadata(encodeMetadata(original));
-    expect(decoded.providers).toHaveLength(0);
-  });
-
-  it('should round-trip empty models list', () => {
-    const original = makeMetadata({
-      providers: [
-        {
-          provider: 'test',
-          models: [],
-          defaultPricing: {
-            inputUsdPerMillion: 0,
-            outputUsdPerMillion: 0,
-          },
-          maxConcurrency: 1,
-          currentLoad: 0,
-        },
-      ],
-    });
-    const decoded = decodeMetadata(encodeMetadata(original));
-    expect(decoded.providers[0]!.models).toEqual([]);
-  });
-
-  it('should decode offerings and optional trailer fields after v2 provider pricing payload', () => {
-    const original = makeMetadata({
-      offerings: [
-        {
-          capability: 'skill',
-          name: 'summarize',
-          description: 'Summarize text',
-          pricing: { unit: 'request', pricePerUnit: 0.1, currency: 'USD' },
-          models: ['claude-3-sonnet'],
-        },
-      ],
-      evmAddress: '0x1111111111111111111111111111111111111111',
-      onChainReputation: 88,
-      onChainSessionCount: 123,
-      onChainDisputeCount: 2,
-    });
-    const decoded = decodeMetadata(encodeMetadata(original));
-    expect(decoded.offerings?.[0]?.name).toBe('summarize');
-    expect(decoded.evmAddress).toBe('0x1111111111111111111111111111111111111111');
-    expect(decoded.onChainReputation).toBe(88);
-    expect(decoded.onChainSessionCount).toBe(123);
-    expect(decoded.onChainDisputeCount).toBe(2);
-  });
-});
-
-describe('encodeMetadataForSigning', () => {
-  it('should produce a shorter buffer than encodeMetadata (no signature)', () => {
-    const metadata = makeMetadata();
-    const forSigning = encodeMetadataForSigning(metadata);
-    const full = encodeMetadata(metadata);
-    // Full includes 64 bytes of signature
-    expect(full.length).toBe(forSigning.length + 64);
-  });
-
-  it('should produce deterministic output for the same input', () => {
-    const metadata = makeMetadata();
-    const a = encodeMetadataForSigning(metadata);
-    const b = encodeMetadataForSigning(metadata);
-    expect(a).toEqual(b);
-  });
-});

package/tests/metadata-validator.test.ts

@@ -1,261 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  validateMetadata,
-  MAX_METADATA_SIZE,
-  MAX_PROVIDERS,
-  MAX_MODELS_PER_PROVIDER,
-  MAX_MODEL_NAME_LENGTH,
-  MAX_REGION_LENGTH,
-} from '../src/discovery/metadata-validator.js';
-import type { PeerMetadata } from '../src/discovery/peer-metadata.js';
-
-function validMetadata(overrides?: Partial<PeerMetadata>): PeerMetadata {
-  return {
-    peerId: 'a'.repeat(64) as any,
-    version: 2,
-    providers: [
-      {
-        provider: 'anthropic',
-        models: ['claude-3-opus'],
-        defaultPricing: {
-          inputUsdPerMillion: 15,
-          outputUsdPerMillion: 75,
-        },
-        maxConcurrency: 10,
-        currentLoad: 3,
-      },
-    ],
-    region: 'us-east-1',
-    timestamp: Date.now(),
-    signature: 'b'.repeat(128),
-    ...overrides,
-  };
-}
-
-describe('validateMetadata', () => {
-  it('should return no errors for valid metadata', () => {
-    const errors = validateMetadata(validMetadata());
-    expect(errors).toEqual([]);
-  });
-
-  it('should reject wrong version', () => {
-    const errors = validateMetadata(validMetadata({ version: 99 }));
-    expect(errors.some((e) => e.field === 'version')).toBe(true);
-  });
-
-  it('should reject invalid peerId (too short)', () => {
-    const errors = validateMetadata(validMetadata({ peerId: 'abc' as any }));
-    expect(errors.some((e) => e.field === 'peerId')).toBe(true);
-  });
-
-  it('should reject invalid peerId (uppercase)', () => {
-    const errors = validateMetadata(validMetadata({ peerId: 'A'.repeat(64) as any }));
-    expect(errors.some((e) => e.field === 'peerId')).toBe(true);
-  });
-
-  it('should reject empty region', () => {
-    const errors = validateMetadata(validMetadata({ region: '' }));
-    expect(errors.some((e) => e.field === 'region')).toBe(true);
-  });
-
-  it('should reject region exceeding max length', () => {
-    const errors = validateMetadata(validMetadata({ region: 'x'.repeat(MAX_REGION_LENGTH + 1) }));
-    expect(errors.some((e) => e.field === 'region')).toBe(true);
-  });
-
-  it('should reject non-positive timestamp', () => {
-    const errors = validateMetadata(validMetadata({ timestamp: 0 }));
-    expect(errors.some((e) => e.field === 'timestamp')).toBe(true);
-  });
-
-  it('should reject NaN timestamp', () => {
-    const errors = validateMetadata(validMetadata({ timestamp: NaN }));
-    expect(errors.some((e) => e.field === 'timestamp')).toBe(true);
-  });
-
-  it('should reject zero providers', () => {
-    const errors = validateMetadata(validMetadata({ providers: [] }));
-    expect(errors.some((e) => e.field === 'providers')).toBe(true);
-  });
-
-  it('should reject too many providers', () => {
-    const providers = Array.from({ length: MAX_PROVIDERS + 1 }, (_, i) => ({
-      provider: `p${i}`,
-      models: ['m'],
-      defaultPricing: {
-        inputUsdPerMillion: 1,
-        outputUsdPerMillion: 1,
-      },
-      maxConcurrency: 1,
-      currentLoad: 0,
-    }));
-    const errors = validateMetadata(validMetadata({ providers }));
-    expect(errors.some((e) => e.field === 'providers')).toBe(true);
-  });
-
-  it('should reject too many models per provider', () => {
-    const models = Array.from({ length: MAX_MODELS_PER_PROVIDER + 1 }, (_, i) => `model-${i}`);
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models,
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: 1,
-            },
-            maxConcurrency: 1,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('models'))).toBe(true);
-  });
-
-  it('should reject model name exceeding max length', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['x'.repeat(MAX_MODEL_NAME_LENGTH + 1)],
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: 1,
-            },
-            maxConcurrency: 1,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('models'))).toBe(true);
-  });
-
-  it('should reject negative default input price', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['m'],
-            defaultPricing: {
-              inputUsdPerMillion: -1,
-              outputUsdPerMillion: 1,
-            },
-            maxConcurrency: 1,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('defaultPricing.inputUsdPerMillion'))).toBe(true);
-  });
-
-  it('should reject negative default output price', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['m'],
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: -1,
-            },
-            maxConcurrency: 1,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('defaultPricing.outputUsdPerMillion'))).toBe(true);
-  });
-
-  it('should reject model pricing entries with missing output half', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['m'],
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: 1,
-            },
-            modelPricing: {
-              m: {
-                inputUsdPerMillion: 2,
-              } as any,
-            } as any,
-            maxConcurrency: 1,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('modelPricing.m.outputUsdPerMillion'))).toBe(true);
-  });
-
-  it('should reject maxConcurrency < 1', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['m'],
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: 1,
-            },
-            maxConcurrency: 0,
-            currentLoad: 0,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('maxConcurrency'))).toBe(true);
-  });
-
-  it('should reject currentLoad > maxConcurrency', () => {
-    const errors = validateMetadata(
-      validMetadata({
-        providers: [
-          {
-            provider: 'test',
-            models: ['m'],
-            defaultPricing: {
-              inputUsdPerMillion: 1,
-              outputUsdPerMillion: 1,
-            },
-            maxConcurrency: 5,
-            currentLoad: 6,
-          },
-        ],
-      })
-    );
-    expect(errors.some((e) => e.field.includes('currentLoad'))).toBe(true);
-  });
-
-  it('should reject invalid signature format', () => {
-    const errors = validateMetadata(validMetadata({ signature: 'xyz' }));
-    expect(errors.some((e) => e.field === 'signature')).toBe(true);
-  });
-
-  it('should reject signature with uppercase hex', () => {
-    const errors = validateMetadata(validMetadata({ signature: 'B'.repeat(128) }));
-    expect(errors.some((e) => e.field === 'signature')).toBe(true);
-  });
-});
-
-describe('constants', () => {
-  it('should export reasonable constant values', () => {
-    expect(MAX_METADATA_SIZE).toBe(1000);
-    expect(MAX_PROVIDERS).toBe(10);
-    expect(MAX_MODELS_PER_PROVIDER).toBe(20);
-    expect(MAX_MODEL_NAME_LENGTH).toBe(64);
-    expect(MAX_REGION_LENGTH).toBe(32);
-  });
-});

package/tests/metering-storage.test.ts

@@ -1,244 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { MeteringStorage } from '../src/metering/storage.js';
-import type {
-  MeteringEvent,
-  UsageReceipt,
-  ReceiptVerification,
-  SessionMetrics,
-  TokenCount,
-} from '../src/types/metering.js';
-
-let storage: MeteringStorage;
-
-function makeTokens(total: number): TokenCount {
-  return {
-    inputTokens: Math.floor(total * 0.6),
-    outputTokens: Math.ceil(total * 0.4),
-    totalTokens: total,
-    method: 'content-length',
-    confidence: 'high',
-  };
-}
-
-function makeEvent(overrides?: Partial<MeteringEvent>): MeteringEvent {
-  return {
-    eventId: `evt-${Math.random().toString(36).slice(2)}`,
-    sessionId: 'session-1',
-    timestamp: Date.now(),
-    provider: 'openai',
-    sellerPeerId: 'seller-1',
-    buyerPeerId: 'buyer-1',
-    tokens: makeTokens(1000),
-    latencyMs: 150,
-    statusCode: 200,
-    wasStreaming: false,
-    ...overrides,
-  };
-}
-
-function makeReceipt(overrides?: Partial<UsageReceipt>): UsageReceipt {
-  return {
-    receiptId: `rcpt-${Math.random().toString(36).slice(2)}`,
-    sessionId: 'session-1',
-    eventId: 'evt-1',
-    timestamp: Date.now(),
-    provider: 'openai',
-    sellerPeerId: 'seller-1',
-    buyerPeerId: 'buyer-1',
-    tokens: makeTokens(1000),
-    unitPriceCentsPerThousandTokens: 10,
-    costCents: 10,
-    signature: 'a'.repeat(128),
-    ...overrides,
-  };
-}
-
-function makeVerification(overrides?: Partial<ReceiptVerification>): ReceiptVerification {
-  return {
-    receiptId: `rcpt-${Math.random().toString(36).slice(2)}`,
-    signatureValid: true,
-    buyerTokenEstimate: makeTokens(1000),
-    sellerTokenEstimate: makeTokens(1050),
-    tokenDifference: 50,
-    percentageDifference: 4.76,
-    disputed: false,
-    verifiedAt: Date.now(),
-    ...overrides,
-  };
-}
-
-function makeSession(overrides?: Partial<SessionMetrics>): SessionMetrics {
-  return {
-    sessionId: `sess-${Math.random().toString(36).slice(2)}`,
-    sellerPeerId: 'seller-1',
-    buyerPeerId: 'buyer-1',
-    provider: 'openai',
-    startedAt: Date.now(),
-    endedAt: null,
-    totalRequests: 5,
-    totalTokens: 5000,
-    totalCostCents: 50,
-    avgLatencyMs: 200,
-    peerSwitches: 0,
-    disputedReceipts: 0,
-    ...overrides,
-  };
-}
-
-beforeEach(() => {
-  storage = new MeteringStorage(':memory:');
-});
-
-afterEach(() => {
-  storage.close();
-});
-
-describe('MeteringStorage — Events', () => {
-  it('should insert and retrieve events by session', () => {
-    const event = makeEvent({ sessionId: 'sess-a' });
-    storage.insertEvent(event);
-
-    const events = storage.getEventsBySession('sess-a');
-    expect(events).toHaveLength(1);
-    expect(events[0]!.eventId).toBe(event.eventId);
-    expect(events[0]!.tokens.totalTokens).toBe(1000);
-    expect(events[0]!.wasStreaming).toBe(false);
-  });
-
-  it('should retrieve events by time range', () => {
-    const now = Date.now();
-    storage.insertEvent(makeEvent({ eventId: 'e1', timestamp: now - 2000 }));
-    storage.insertEvent(makeEvent({ eventId: 'e2', timestamp: now - 500 }));
-    storage.insertEvent(makeEvent({ eventId: 'e3', timestamp: now + 1000 }));
-
-    const events = storage.getEventsByTimeRange(now - 3000, now);
-    expect(events).toHaveLength(2);
-  });
-
-  it('should return empty for non-existent session', () => {
-    expect(storage.getEventsBySession('nonexistent')).toEqual([]);
-  });
-});
-
-describe('MeteringStorage — Receipts', () => {
-  it('should insert and retrieve receipts by session', () => {
-    const receipt = makeReceipt({ sessionId: 'sess-b' });
-    storage.insertReceipt(receipt);
-
-    const receipts = storage.getReceiptsBySession('sess-b');
-    expect(receipts).toHaveLength(1);
-    expect(receipts[0]!.costCents).toBe(10);
-    expect(receipts[0]!.signature).toBe('a'.repeat(128));
-  });
-
-  it('should calculate total cost in a time range', () => {
-    const now = Date.now();
-    storage.insertReceipt(makeReceipt({ receiptId: 'r1', timestamp: now - 500, costCents: 10 }));
-    storage.insertReceipt(makeReceipt({ receiptId: 'r2', timestamp: now - 200, costCents: 20 }));
-    storage.insertReceipt(makeReceipt({ receiptId: 'r3', timestamp: now + 1000, costCents: 100 }));
-
-    const total = storage.getTotalCost(now - 1000, now);
-    expect(total).toBe(30);
-  });
-
-  it('should return 0 total cost for empty range', () => {
-    expect(storage.getTotalCost(0, 1)).toBe(0);
-  });
-});
-
-describe('MeteringStorage — Verifications', () => {
-  it('should insert and retrieve disputed verifications', () => {
-    const now = Date.now();
-    storage.insertVerification(
-      makeVerification({ receiptId: 'v1', disputed: true, verifiedAt: now - 100 })
-    );
-    storage.insertVerification(
-      makeVerification({ receiptId: 'v2', disputed: false, verifiedAt: now - 50 })
-    );
-
-    const disputed = storage.getDisputedVerifications(now - 200, now + 200);
-    expect(disputed).toHaveLength(1);
-    expect(disputed[0]!.receiptId).toBe('v1');
-    expect(disputed[0]!.disputed).toBe(true);
-  });
-});
-
-describe('MeteringStorage — Sessions', () => {
-  it('should upsert and retrieve a session', () => {
-    const session = makeSession({ sessionId: 'sess-x' });
-    storage.upsertSession(session);
-
-    const retrieved = storage.getSession('sess-x');
-    expect(retrieved).not.toBeNull();
-    expect(retrieved!.totalRequests).toBe(5);
-    expect(retrieved!.endedAt).toBeNull();
-  });
-
-  it('should update session on upsert with same ID', () => {
-    const session = makeSession({ sessionId: 'sess-y', totalRequests: 1 });
-    storage.upsertSession(session);
-
-    session.totalRequests = 10;
-    session.endedAt = Date.now();
-    storage.upsertSession(session);
-
-    const retrieved = storage.getSession('sess-y');
-    expect(retrieved!.totalRequests).toBe(10);
-    expect(retrieved!.endedAt).not.toBeNull();
-  });
-
-  it('should return null for non-existent session', () => {
-    expect(storage.getSession('nonexistent')).toBeNull();
-  });
-
-  it('should get session summary for a time range', () => {
-    const now = Date.now();
-    storage.upsertSession(makeSession({ sessionId: 's1', startedAt: now - 500, totalCostCents: 10, totalTokens: 1000, totalRequests: 5 }));
-    storage.upsertSession(makeSession({ sessionId: 's2', startedAt: now - 200, totalCostCents: 20, totalTokens: 2000, totalRequests: 3 }));
-
-    const summary = storage.getSessionSummary(now - 1000, now);
-    expect(summary.sessionCount).toBe(2);
-    expect(summary.totalCostCents).toBe(30);
-    expect(summary.totalTokens).toBe(3000);
-    expect(summary.totalRequests).toBe(8);
-  });
-
-  it('should get event token summary', () => {
-    const now = Date.now();
-    storage.insertEvent(makeEvent({ eventId: 'e1', timestamp: now - 500, tokens: makeTokens(1000) }));
-    storage.insertEvent(makeEvent({ eventId: 'e2', timestamp: now - 200, tokens: makeTokens(2000) }));
-
-    const summary = storage.getEventTokenSummary(now - 1000, now);
-    expect(summary.totalRequests).toBe(2);
-    expect(summary.totalTokens).toBe(3000);
-  });
-});
-
-describe('MeteringStorage — Pruning', () => {
-  it('should delete data older than given timestamp', () => {
-    const now = Date.now();
-    const old = now - 100000;
-    const recent = now - 100;
-
-    storage.insertEvent(makeEvent({ eventId: 'old-e', timestamp: old }));
-    storage.insertEvent(makeEvent({ eventId: 'new-e', timestamp: recent }));
-    storage.insertReceipt(makeReceipt({ receiptId: 'old-r', timestamp: old }));
-    storage.insertReceipt(makeReceipt({ receiptId: 'new-r', timestamp: recent }));
-    storage.insertVerification(makeVerification({ receiptId: 'old-v', verifiedAt: old, disputed: true }));
-    storage.insertVerification(makeVerification({ receiptId: 'new-v', verifiedAt: recent, disputed: true }));
-    storage.upsertSession(makeSession({ sessionId: 'old-s', startedAt: old }));
-    storage.upsertSession(makeSession({ sessionId: 'new-s', startedAt: recent }));
-
-    const cutoff = now - 50000;
-    const result = storage.pruneOlderThan(cutoff);
-
-    expect(result.eventsDeleted).toBe(1);
-    expect(result.receiptsDeleted).toBe(1);
-    expect(result.verificationsDeleted).toBe(1);
-    expect(result.sessionsDeleted).toBe(1);
-
-    // Recent data should still exist
-    expect(storage.getEventsByTimeRange(recent - 10, recent + 10)).toHaveLength(1);
-    expect(storage.getReceiptsByTimeRange(recent - 10, recent + 10)).toHaveLength(1);
-  });
-});