@antseed/node 0.1.0

package/tests/payment-codec.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import {
+  encodeSessionLockAuth, decodeSessionLockAuth,
+  encodeSessionLockConfirm, decodeSessionLockConfirm,
+  encodeSessionLockReject, decodeSessionLockReject,
+  encodeSellerReceipt, decodeSellerReceipt,
+  encodeBuyerAck, decodeBuyerAck,
+  encodeSessionEnd, decodeSessionEnd,
+  encodeTopUpRequest, decodeTopUpRequest,
+  encodeTopUpAuth, decodeTopUpAuth,
+  encodeDisputeNotify, decodeDisputeNotify,
+} from '../src/p2p/payment-codec.js';
+
+describe('payment codec round-trips', () => {
+  it('SessionLockAuth', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      lockedAmount: '1000000',
+      buyerSig: 'b'.repeat(128),
+    };
+    const encoded = encodeSessionLockAuth(payload);
+    const decoded = decodeSessionLockAuth(encoded);
+    expect(decoded).toEqual(payload);
+  });
+
+  it('SessionLockConfirm', () => {
+    const payload = { sessionId: 'a'.repeat(64), txSignature: 'tx123' };
+    expect(decodeSessionLockConfirm(encodeSessionLockConfirm(payload))).toEqual(payload);
+  });
+
+  it('SessionLockReject', () => {
+    const payload = { sessionId: 'a'.repeat(64), reason: 'Insufficient funds' };
+    expect(decodeSessionLockReject(encodeSessionLockReject(payload))).toEqual(payload);
+  });
+
+  it('SellerReceipt', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      runningTotal: '500000',
+      requestCount: 5,
+      responseHash: 'c'.repeat(64),
+      sellerSig: 'd'.repeat(128),
+    };
+    expect(decodeSellerReceipt(encodeSellerReceipt(payload))).toEqual(payload);
+  });
+
+  it('BuyerAck', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      runningTotal: '500000',
+      requestCount: 5,
+      buyerSig: 'e'.repeat(128),
+    };
+    expect(decodeBuyerAck(encodeBuyerAck(payload))).toEqual(payload);
+  });
+
+  it('SessionEnd', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      runningTotal: '500000',
+      requestCount: 5,
+      score: 85,
+      buyerSig: 'f'.repeat(128),
+    };
+    expect(decodeSessionEnd(encodeSessionEnd(payload))).toEqual(payload);
+  });
+
+  it('TopUpRequest', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      additionalAmount: '500000',
+      currentRunningTotal: '400000',
+      currentLockedAmount: '500000',
+    };
+    expect(decodeTopUpRequest(encodeTopUpRequest(payload))).toEqual(payload);
+  });
+
+  it('TopUpAuth', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      additionalAmount: '500000',
+      buyerSig: 'g'.repeat(128),
+    };
+    expect(decodeTopUpAuth(encodeTopUpAuth(payload))).toEqual(payload);
+  });
+
+  it('DisputeNotify', () => {
+    const payload = {
+      sessionId: 'a'.repeat(64),
+      reason: 'Unacknowledged service',
+      txSignature: 'tx456',
+    };
+    expect(decodeDisputeNotify(encodeDisputeNotify(payload))).toEqual(payload);
+  });
+});

package/tests/payment-mux.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from 'vitest';
+import { PaymentMux } from '../src/p2p/payment-mux.js';
+import { MessageType, type FramedMessage } from '../src/types/protocol.js';
+import * as codec from '../src/p2p/payment-codec.js';
+import type { PeerConnection } from '../src/p2p/connection-manager.js';
+
+function mockConnection(): PeerConnection {
+  return { send: vi.fn() } as unknown as PeerConnection;
+}
+
+describe('PaymentMux', () => {
+  describe('isPaymentMessage correctly identifies range', () => {
+    it('returns true for 0x50-0x58', () => {
+      for (let type = 0x50; type <= 0x58; type++) {
+        expect(PaymentMux.isPaymentMessage(type)).toBe(true);
+      }
+    });
+
+    it('returns true for 0x59-0x5F (rest of payment range)', () => {
+      for (let type = 0x59; type <= 0x5f; type++) {
+        expect(PaymentMux.isPaymentMessage(type)).toBe(true);
+      }
+    });
+
+    it('returns false for non-payment types', () => {
+      expect(PaymentMux.isPaymentMessage(0x01)).toBe(false);
+      expect(PaymentMux.isPaymentMessage(0x20)).toBe(false);
+      expect(PaymentMux.isPaymentMessage(0x4f)).toBe(false);
+      expect(PaymentMux.isPaymentMessage(0x60)).toBe(false);
+      expect(PaymentMux.isPaymentMessage(0xff)).toBe(false);
+    });
+  });
+
+  describe('handleFrame returns false for non-payment messages', () => {
+    it('returns false for HttpRequest', async () => {
+      const mux = new PaymentMux(mockConnection());
+      const frame: FramedMessage = {
+        type: MessageType.HttpRequest,
+        messageId: 1,
+        payload: new Uint8Array(0),
+      };
+      expect(await mux.handleFrame(frame)).toBe(false);
+    });
+
+    it('returns false for Ping', async () => {
+      const mux = new PaymentMux(mockConnection());
+      const frame: FramedMessage = {
+        type: MessageType.Ping,
+        messageId: 1,
+        payload: new Uint8Array(0),
+      };
+      expect(await mux.handleFrame(frame)).toBe(false);
+    });
+  });
+
+  describe('handleFrame dispatches to correct handler', () => {
+    it('dispatches SessionLockAuth', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+      const handler = vi.fn();
+      mux.onSessionLockAuth(handler);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        lockedAmount: '1000000',
+        buyerSig: 'b'.repeat(128),
+      };
+      const frame: FramedMessage = {
+        type: MessageType.SessionLockAuth,
+        messageId: 1,
+        payload: codec.encodeSessionLockAuth(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalledWith(payload);
+    });
+
+    it('dispatches SellerReceipt', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+      const handler = vi.fn();
+      mux.onSellerReceipt(handler);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        runningTotal: '500000',
+        requestCount: 5,
+        responseHash: 'c'.repeat(64),
+        sellerSig: 'd'.repeat(128),
+      };
+      const frame: FramedMessage = {
+        type: MessageType.SellerReceipt,
+        messageId: 2,
+        payload: codec.encodeSellerReceipt(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalledWith(payload);
+    });
+
+    it('dispatches BuyerAck', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+      const handler = vi.fn();
+      mux.onBuyerAck(handler);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        runningTotal: '500000',
+        requestCount: 5,
+        buyerSig: 'e'.repeat(128),
+      };
+      const frame: FramedMessage = {
+        type: MessageType.BuyerAck,
+        messageId: 3,
+        payload: codec.encodeBuyerAck(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalledWith(payload);
+    });
+
+    it('dispatches SessionEnd', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+      const handler = vi.fn();
+      mux.onSessionEnd(handler);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        runningTotal: '500000',
+        requestCount: 5,
+        score: 85,
+        buyerSig: 'f'.repeat(128),
+      };
+      const frame: FramedMessage = {
+        type: MessageType.SessionEnd,
+        messageId: 4,
+        payload: codec.encodeSessionEnd(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalledWith(payload);
+    });
+
+    it('dispatches DisputeNotify', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+      const handler = vi.fn();
+      mux.onDisputeNotify(handler);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        reason: 'Unacknowledged service',
+        txSignature: 'tx456',
+      };
+      const frame: FramedMessage = {
+        type: MessageType.DisputeNotify,
+        messageId: 5,
+        payload: codec.encodeDisputeNotify(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalledWith(payload);
+    });
+
+    it('returns true even with no handler registered', async () => {
+      const conn = mockConnection();
+      const mux = new PaymentMux(conn);
+
+      const payload = {
+        sessionId: 'a'.repeat(64),
+        lockedAmount: '1000000',
+        buyerSig: 'b'.repeat(128),
+      };
+      const frame: FramedMessage = {
+        type: MessageType.SessionLockAuth,
+        messageId: 1,
+        payload: codec.encodeSessionLockAuth(payload),
+      };
+
+      const result = await mux.handleFrame(frame);
+      expect(result).toBe(true);
+    });
+  });
+});

package/tests/peer-selector.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import {
+  scorePeer,
+  rankPeers,
+  selectBestPeer,
+  selectDiversePeers,
+  DEFAULT_SCORING_WEIGHTS,
+  type PeerCandidate,
+} from '../src/discovery/peer-selector.js';
+
+function makeCandidate(overrides?: Partial<PeerCandidate>): PeerCandidate {
+  return {
+    peerId: 'peer-1',
+    region: 'us-east-1',
+    inputUsdPerMillion: 0.01,
+    maxConcurrency: 10,
+    currentLoad: 0,
+    latencyMs: 100,
+    reputation: 0.9,
+    ...overrides,
+  };
+}
+
+describe('scorePeer', () => {
+  it('should return a score between 0 and 1', () => {
+    const score = scorePeer(makeCandidate(), 0.01);
+    expect(score).toBeGreaterThanOrEqual(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  it('should give perfect score to ideal candidate', () => {
+    const candidate = makeCandidate({
+      inputUsdPerMillion: 0.01,
+      maxConcurrency: 10,
+      currentLoad: 0,
+      latencyMs: 0,
+      reputation: 1,
+    });
+    const score = scorePeer(candidate, 0.01);
+    expect(score).toBeCloseTo(1.0, 2);
+  });
+
+  it('should give lower score to more expensive peers', () => {
+    const cheap = makeCandidate({ inputUsdPerMillion: 0.01 });
+    const expensive = makeCandidate({ inputUsdPerMillion: 0.10 });
+    const cheapScore = scorePeer(cheap, 0.01);
+    const expensiveScore = scorePeer(expensive, 0.01);
+    expect(cheapScore).toBeGreaterThan(expensiveScore);
+  });
+
+  it('should give lower score to heavily loaded peers', () => {
+    const idle = makeCandidate({ currentLoad: 0, maxConcurrency: 10 });
+    const loaded = makeCandidate({ currentLoad: 9, maxConcurrency: 10 });
+    expect(scorePeer(idle, 0.01)).toBeGreaterThan(scorePeer(loaded, 0.01));
+  });
+
+  it('should give lower score to high-latency peers', () => {
+    const fast = makeCandidate({ latencyMs: 50 });
+    const slow = makeCandidate({ latencyMs: 10000 });
+    expect(scorePeer(fast, 0.01)).toBeGreaterThan(scorePeer(slow, 0.01));
+  });
+
+  it('should handle zero price (free) as perfect price score', () => {
+    const free = makeCandidate({ inputUsdPerMillion: 0 });
+    const score = scorePeer(free, 0.01);
+    // price score = 1.0 for free peers
+    expect(score).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should handle maxConcurrency = 0 as zero capacity', () => {
+    const candidate = makeCandidate({ maxConcurrency: 0, currentLoad: 0 });
+    // capacity score = 0 when maxConcurrency is 0
+    const score = scorePeer(candidate, 0.01);
+    expect(score).toBeLessThan(1);
+  });
+
+  it('should clamp latency score at 0 for >= 15000ms', () => {
+    const verySlowA = makeCandidate({ latencyMs: 15000 });
+    const verySlowB = makeCandidate({ latencyMs: 20000 });
+    expect(scorePeer(verySlowA, 0.01)).toEqual(scorePeer(verySlowB, 0.01));
+  });
+
+  it('should accept custom weights', () => {
+    // Use a candidate where price score and capacity score differ
+    const candidate = makeCandidate({
+      inputUsdPerMillion: 0.05, // price score = 0.01/0.05 = 0.2
+      maxConcurrency: 10,
+      currentLoad: 5, // capacity score = 5/10 = 0.5
+      latencyMs: 0,
+      reputation: 0,
+    });
+    const priceOnly = { price: 1, capacity: 0, latency: 0, reputation: 0 };
+    const capOnly = { price: 0, capacity: 1, latency: 0, reputation: 0 };
+    const s1 = scorePeer(candidate, 0.01, priceOnly);
+    const s2 = scorePeer(candidate, 0.01, capOnly);
+    expect(s1).not.toBe(s2);
+    expect(s1).toBeCloseTo(0.2, 2);
+    expect(s2).toBeCloseTo(0.5, 2);
+  });
+});
+
+describe('rankPeers', () => {
+  it('should return empty array for empty input', () => {
+    expect(rankPeers([])).toEqual([]);
+  });
+
+  it('should sort peers by score descending', () => {
+    const candidates = [
+      makeCandidate({ peerId: 'expensive', inputUsdPerMillion: 1.0, latencyMs: 5000 }),
+      makeCandidate({ peerId: 'cheap', inputUsdPerMillion: 0.001, latencyMs: 50 }),
+    ];
+    const ranked = rankPeers(candidates);
+    expect(ranked[0]!.candidate.peerId).toBe('cheap');
+    expect(ranked[0]!.score).toBeGreaterThan(ranked[1]!.score);
+  });
+
+  it('should derive cheapest price automatically', () => {
+    const candidates = [
+      makeCandidate({ peerId: 'a', inputUsdPerMillion: 0.1 }),
+      makeCandidate({ peerId: 'b', inputUsdPerMillion: 0.01 }),
+    ];
+    const ranked = rankPeers(candidates);
+    // 'b' is cheapest so it should have perfect price score
+    expect(ranked[0]!.candidate.peerId).toBe('b');
+  });
+});
+
+describe('selectBestPeer', () => {
+  it('should return null for empty candidates', () => {
+    expect(selectBestPeer([])).toBeNull();
+  });
+
+  it('should return the highest-scoring peer', () => {
+    const candidates = [
+      makeCandidate({ peerId: 'slow', latencyMs: 10000, inputUsdPerMillion: 1 }),
+      makeCandidate({ peerId: 'fast', latencyMs: 10, inputUsdPerMillion: 0.001 }),
+    ];
+    const best = selectBestPeer(candidates);
+    expect(best).not.toBeNull();
+    expect(best!.candidate.peerId).toBe('fast');
+  });
+});
+
+describe('selectDiversePeers', () => {
+  it('should return all peers when count >= candidates', () => {
+    const candidates = [makeCandidate({ peerId: 'a' }), makeCandidate({ peerId: 'b' })];
+    const result = selectDiversePeers(candidates, 5);
+    expect(result).toHaveLength(2);
+  });
+
+  it('should prefer peers from different regions', () => {
+    const candidates = [
+      makeCandidate({ peerId: 'us1', region: 'us-east-1', inputUsdPerMillion: 0.01 }),
+      makeCandidate({ peerId: 'us2', region: 'us-east-1', inputUsdPerMillion: 0.02 }),
+      makeCandidate({ peerId: 'eu1', region: 'eu-west-1', inputUsdPerMillion: 0.03 }),
+    ];
+    const result = selectDiversePeers(candidates, 2);
+    expect(result).toHaveLength(2);
+    const regions = result.map((r) => r.candidate.region);
+    expect(regions).toContain('us-east-1');
+    expect(regions).toContain('eu-west-1');
+  });
+
+  it('should fill remaining slots by score after region diversity', () => {
+    const candidates = [
+      makeCandidate({ peerId: 'a', region: 'us', inputUsdPerMillion: 0.001 }),
+      makeCandidate({ peerId: 'b', region: 'us', inputUsdPerMillion: 0.01 }),
+      makeCandidate({ peerId: 'c', region: 'eu', inputUsdPerMillion: 0.1 }),
+    ];
+    const result = selectDiversePeers(candidates, 3);
+    expect(result).toHaveLength(3);
+  });
+});
+
+describe('DEFAULT_SCORING_WEIGHTS', () => {
+  it('should sum to approximately 1.0', () => {
+    const sum =
+      DEFAULT_SCORING_WEIGHTS.price +
+      DEFAULT_SCORING_WEIGHTS.capacity +
+      DEFAULT_SCORING_WEIGHTS.latency +
+      DEFAULT_SCORING_WEIGHTS.reputation;
+    expect(sum).toBeCloseTo(1.0, 5);
+  });
+});

package/tests/provider-detection.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import {
+  detectProviderFromHeaders,
+  detectProviderFromPath,
+  resolveProvider,
+  ANTSEED_PROVIDER_HEADER,
+} from '../src/proxy/provider-detection.js';
+
+describe('detectProviderFromHeaders', () => {
+  it('should detect anthropic from header', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: 'anthropic' })).toBe('anthropic');
+  });
+
+  it('should detect openai from header', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: 'openai' })).toBe('openai');
+  });
+
+  it('should detect google from header', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: 'google' })).toBe('google');
+  });
+
+  it('should detect moonshot from header', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: 'moonshot' })).toBe('moonshot');
+  });
+
+  it('should be case-insensitive for header name', () => {
+    expect(detectProviderFromHeaders({ 'X-ANTSEED-PROVIDER': 'anthropic' })).toBe('anthropic');
+  });
+
+  it('should trim and lowercase the header value', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: '  OPENAI  ' })).toBe('openai');
+  });
+
+  it('should return null for unknown provider', () => {
+    expect(detectProviderFromHeaders({ [ANTSEED_PROVIDER_HEADER]: 'unknown' })).toBeNull();
+  });
+
+  it('should return null when header is missing', () => {
+    expect(detectProviderFromHeaders({ 'content-type': 'application/json' })).toBeNull();
+  });
+});
+
+describe('detectProviderFromPath', () => {
+  it('should detect anthropic from /v1/messages', () => {
+    expect(detectProviderFromPath('/v1/messages')).toBe('anthropic');
+  });
+
+  it('should detect anthropic from /v1/complete', () => {
+    expect(detectProviderFromPath('/v1/complete')).toBe('anthropic');
+  });
+
+  it('should detect openai from /v1/chat/completions', () => {
+    expect(detectProviderFromPath('/v1/chat/completions')).toBe('openai');
+  });
+
+  it('should detect openai from /v1/completions', () => {
+    expect(detectProviderFromPath('/v1/completions')).toBe('openai');
+  });
+
+  it('should detect openai from /v1/embeddings', () => {
+    expect(detectProviderFromPath('/v1/embeddings')).toBe('openai');
+  });
+
+  it('should detect google from /v1beta/ paths', () => {
+    expect(detectProviderFromPath('/v1beta/models/gemini-pro:generateContent')).toBe('google');
+  });
+
+  it('should detect google from /v1/models/gemini paths', () => {
+    expect(detectProviderFromPath('/v1/models/gemini-pro:generateContent')).toBe('google');
+  });
+
+  it('should detect moonshot from paths containing moonshot', () => {
+    expect(detectProviderFromPath('/v1/moonshot/chat/completions')).toBe('moonshot');
+  });
+
+  it('should prioritize moonshot over openai for ambiguous paths', () => {
+    // moonshot check happens before openai
+    expect(detectProviderFromPath('/v1/chat/moonshot/completions')).toBe('moonshot');
+  });
+
+  it('should return null for unrecognized paths', () => {
+    expect(detectProviderFromPath('/api/v2/infer')).toBeNull();
+  });
+
+  it('should be case-insensitive', () => {
+    expect(detectProviderFromPath('/V1/Messages')).toBe('anthropic');
+  });
+});
+
+describe('resolveProvider', () => {
+  it('should prefer header over path', () => {
+    const result = resolveProvider('/v1/chat/completions', {
+      [ANTSEED_PROVIDER_HEADER]: 'anthropic',
+    }, 'openai');
+    expect(result).toBe('anthropic');
+  });
+
+  it('should fall back to path when header is absent', () => {
+    const result = resolveProvider('/v1/messages', {}, 'openai');
+    expect(result).toBe('anthropic');
+  });
+
+  it('should fall back to default when neither header nor path matches', () => {
+    const result = resolveProvider('/unknown', {}, 'openai');
+    expect(result).toBe('openai');
+  });
+});

package/tests/proxy-mux-security.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { ProxyMux } from '../src/proxy/proxy-mux.js';
+import { MessageType } from '../src/types/protocol.js';
+import type { PeerConnection } from '../src/p2p/connection-manager.js';
+
+function createMux(): ProxyMux {
+  const conn = {
+    send: () => {},
+  } as unknown as PeerConnection;
+
+  return new ProxyMux(conn);
+}
+
+describe('ProxyMux security handling', () => {
+  it('rejects malformed payloads instead of silently proceeding', async () => {
+    const mux = createMux();
+
+    await expect(
+      mux.handleFrame({
+        type: MessageType.HttpResponse,
+        messageId: 1,
+        payload: new Uint8Array([0x01]),
+      }),
+    ).rejects.toThrow('Failed to handle proxy frame type');
+  });
+
+  it('ignores unknown frame types', async () => {
+    const mux = createMux();
+
+    await expect(
+      mux.handleFrame({
+        type: 0x99 as MessageType,
+        messageId: 2,
+        payload: new Uint8Array(),
+      }),
+    ).resolves.toBeUndefined();
+  });
+});