@antseed/node 0.1.0 → 0.1.1

package/tests/payment-codec.test.ts

@@ -1,95 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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();
-  });
-});