@antseed/node 0.1.0

package/tests/receipt.test.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ReceiptGenerator,
+  buildSignaturePayload,
+  calculateCost,
+  type Signer,
+} from '../src/metering/receipt-generator.js';
+import { ReceiptVerifier, type SignatureVerifier } from '../src/metering/receipt-verifier.js';
+import type { TokenCount, UsageReceipt } from '../src/types/metering.js';
+
+function makeTokenCount(total: number): TokenCount {
+  return {
+    inputTokens: Math.floor(total * 0.6),
+    outputTokens: Math.ceil(total * 0.4),
+    totalTokens: total,
+    method: 'content-length',
+    confidence: 'high',
+  };
+}
+
+function makeSigner(peerId: string): Signer {
+  return {
+    peerId,
+    sign(message: string): string {
+      // Deterministic fake signature for testing
+      return 'f'.repeat(128);
+    },
+  };
+}
+
+function makeVerifier(alwaysValid: boolean): SignatureVerifier {
+  return {
+    verify(_message: string, _signature: string, _publicKeyHex: string): boolean {
+      return alwaysValid;
+    },
+  };
+}
+
+describe('calculateCost', () => {
+  it('should calculate cost for 1000 tokens at 10 cents/1K', () => {
+    expect(calculateCost(1000, 10)).toBe(10);
+  });
+
+  it('should round to nearest cent', () => {
+    // 1500 tokens at 10 cents/1K = 15 cents
+    expect(calculateCost(1500, 10)).toBe(15);
+  });
+
+  it('should return minimum of 1 cent for non-zero cost', () => {
+    // 1 token at 0.001 cents/1K = 0.000001 cents -> rounds to 0, but min is 1
+    expect(calculateCost(1, 1)).toBe(1);
+  });
+
+  it('should return 0 for zero tokens', () => {
+    expect(calculateCost(0, 10)).toBe(0);
+  });
+
+  it('should return 0 for zero price', () => {
+    expect(calculateCost(1000, 0)).toBe(0);
+  });
+});
+
+describe('buildSignaturePayload', () => {
+  it('should produce a pipe-delimited string', () => {
+    const payload = buildSignaturePayload({
+      receiptId: 'r1',
+      sessionId: 's1',
+      eventId: 'e1',
+      timestamp: 1000,
+      provider: 'openai',
+      sellerPeerId: 'seller',
+      buyerPeerId: 'buyer',
+      tokens: makeTokenCount(500),
+      unitPriceCentsPerThousandTokens: 10,
+      costCents: 5,
+    });
+
+    expect(payload).toBe('r1|s1|e1|1000|openai|seller|buyer|500|5');
+  });
+
+  it('should be deterministic', () => {
+    const data = {
+      receiptId: 'r1',
+      sessionId: 's1',
+      eventId: 'e1',
+      timestamp: 1000,
+      provider: 'openai' as const,
+      sellerPeerId: 'seller',
+      buyerPeerId: 'buyer',
+      tokens: makeTokenCount(500),
+      unitPriceCentsPerThousandTokens: 10,
+      costCents: 5,
+    };
+    expect(buildSignaturePayload(data)).toBe(buildSignaturePayload(data));
+  });
+});
+
+describe('ReceiptGenerator', () => {
+  it('should generate a complete receipt', () => {
+    const signer = makeSigner('seller-peer-id');
+    const generator = new ReceiptGenerator(signer);
+
+    const receipt = generator.generate(
+      'session-1',
+      'event-1',
+      'anthropic',
+      'buyer-peer-id',
+      makeTokenCount(2000),
+      10
+    );
+
+    expect(receipt.receiptId).toBeTruthy();
+    expect(receipt.sessionId).toBe('session-1');
+    expect(receipt.eventId).toBe('event-1');
+    expect(receipt.provider).toBe('anthropic');
+    expect(receipt.sellerPeerId).toBe('seller-peer-id');
+    expect(receipt.buyerPeerId).toBe('buyer-peer-id');
+    expect(receipt.tokens.totalTokens).toBe(2000);
+    expect(receipt.unitPriceCentsPerThousandTokens).toBe(10);
+    expect(receipt.costCents).toBe(20); // 2000/1000 * 10
+    expect(receipt.signature).toBeTruthy();
+    expect(receipt.timestamp).toBeGreaterThan(0);
+  });
+
+  it('should produce unique receipt IDs', () => {
+    const signer = makeSigner('seller');
+    const generator = new ReceiptGenerator(signer);
+    const tokens = makeTokenCount(100);
+
+    const r1 = generator.generate('s', 'e1', 'openai', 'buyer', tokens, 1);
+    const r2 = generator.generate('s', 'e2', 'openai', 'buyer', tokens, 1);
+    expect(r1.receiptId).not.toBe(r2.receiptId);
+  });
+});
+
+describe('ReceiptVerifier', () => {
+  it('should pass verification for valid signature within threshold', () => {
+    const verifier = new ReceiptVerifier(makeVerifier(true));
+
+    const receipt: UsageReceipt = {
+      receiptId: 'r1',
+      sessionId: 's1',
+      eventId: 'e1',
+      timestamp: Date.now(),
+      provider: 'openai',
+      sellerPeerId: 'seller',
+      buyerPeerId: 'buyer',
+      tokens: makeTokenCount(1000),
+      unitPriceCentsPerThousandTokens: 10,
+      costCents: 10,
+      signature: 'f'.repeat(128),
+    };
+
+    const buyerEstimate = makeTokenCount(1050); // 5% difference
+    const result = verifier.verify(receipt, buyerEstimate);
+
+    expect(result.signatureValid).toBe(true);
+    expect(result.disputed).toBe(false);
+    expect(result.percentageDifference).toBeCloseTo(4.76, 1); // |1000-1050|/1050*100
+  });
+
+  it('should flag as disputed when signature is invalid', () => {
+    const verifier = new ReceiptVerifier(makeVerifier(false));
+    const receipt: UsageReceipt = {
+      receiptId: 'r1',
+      sessionId: 's1',
+      eventId: 'e1',
+      timestamp: Date.now(),
+      provider: 'openai',
+      sellerPeerId: 'seller',
+      buyerPeerId: 'buyer',
+      tokens: makeTokenCount(1000),
+      unitPriceCentsPerThousandTokens: 10,
+      costCents: 10,
+      signature: 'bad',
+    };
+
+    const result = verifier.verify(receipt, makeTokenCount(1000));
+    expect(result.signatureValid).toBe(false);
+    expect(result.disputed).toBe(true);
+  });
+
+  it('should flag as disputed when token difference exceeds threshold', () => {
+    const verifier = new ReceiptVerifier(makeVerifier(true), { disputeThresholdPercent: 10 });
+
+    const receipt: UsageReceipt = {
+      receiptId: 'r1',
+      sessionId: 's1',
+      eventId: 'e1',
+      timestamp: Date.now(),
+      provider: 'openai',
+      sellerPeerId: 'seller',
+      buyerPeerId: 'buyer',
+      tokens: makeTokenCount(1000),
+      unitPriceCentsPerThousandTokens: 10,
+      costCents: 10,
+      signature: 'f'.repeat(128),
+    };
+
+    const buyerEstimate = makeTokenCount(800); // 20% difference
+    const result = verifier.verify(receipt, buyerEstimate);
+
+    expect(result.signatureValid).toBe(true);
+    expect(result.disputed).toBe(true);
+    expect(result.percentageDifference).toBeGreaterThan(10);
+  });
+
+  it('should calculate percentage difference correctly', () => {
+    expect(ReceiptVerifier.calculatePercentageDifference(100, 100)).toBe(0);
+    expect(ReceiptVerifier.calculatePercentageDifference(100, 200)).toBe(50);
+    expect(ReceiptVerifier.calculatePercentageDifference(200, 100)).toBe(50);
+    expect(ReceiptVerifier.calculatePercentageDifference(0, 0)).toBe(0);
+    expect(ReceiptVerifier.calculatePercentageDifference(0, 100)).toBe(100);
+  });
+});

package/tests/reputation-integration.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest';
+import { encodeMetadata, decodeMetadata } from '../src/discovery/metadata-codec.js';
+import type { PeerMetadata } from '../src/discovery/peer-metadata.js';
+import type { PeerInfo } from '../src/types/peer.js';
+
+function makeMetadata(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: 1700000000000,
+    signature: 'b'.repeat(128),
+    ...overrides,
+  };
+}
+
+describe('Reputation Integration', () => {
+  it('should round-trip metadata with EVM address and reputation', () => {
+    const original = makeMetadata({
+      evmAddress: '0x1234567890abcdef1234567890abcdef12345678',
+      onChainReputation: 85,
+      onChainSessionCount: 42,
+      onChainDisputeCount: 2,
+    });
+    const encoded = encodeMetadata(original);
+    const decoded = decodeMetadata(encoded);
+
+    expect(decoded.evmAddress).toBe('0x1234567890abcdef1234567890abcdef12345678');
+    expect(decoded.onChainReputation).toBe(85);
+    expect(decoded.onChainSessionCount).toBe(42);
+    expect(decoded.onChainDisputeCount).toBe(2);
+    // Verify other fields are still correct
+    expect(decoded.peerId).toBe(original.peerId);
+    expect(decoded.region).toBe(original.region);
+    expect(decoded.timestamp).toBe(original.timestamp);
+    expect(decoded.providers).toHaveLength(1);
+    expect(decoded.providers[0]!.provider).toBe('anthropic');
+  });
+
+  it('should decode metadata without reputation fields (backward compat)', () => {
+    // Encode without reputation fields
+    const original = makeMetadata();
+    const encoded = encodeMetadata(original);
+    const decoded = decodeMetadata(encoded);
+
+    expect(decoded.evmAddress).toBeUndefined();
+    expect(decoded.onChainReputation).toBeUndefined();
+    expect(decoded.onChainSessionCount).toBeUndefined();
+    expect(decoded.onChainDisputeCount).toBeUndefined();
+    // Core fields should still work
+    expect(decoded.peerId).toBe(original.peerId);
+    expect(decoded.region).toBe(original.region);
+    expect(decoded.timestamp).toBe(original.timestamp);
+  });
+
+  it('should populate PeerInfo from metadata reputation', () => {
+    const metadata: PeerMetadata = makeMetadata({
+      evmAddress: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+      onChainReputation: 92,
+      onChainSessionCount: 100,
+      onChainDisputeCount: 1,
+    });
+
+    // Simulate what _lookupResultToPeerInfo does
+    const peerInfo: PeerInfo = {
+      peerId: metadata.peerId,
+      lastSeen: metadata.timestamp,
+      providers: metadata.providers.map((p) => p.provider),
+      publicAddress: '1.2.3.4:6882',
+      evmAddress: metadata.evmAddress,
+      onChainReputation: metadata.onChainReputation,
+      onChainSessionCount: metadata.onChainSessionCount,
+      onChainDisputeCount: metadata.onChainDisputeCount,
+      trustScore: metadata.onChainReputation,
+    };
+
+    expect(peerInfo.evmAddress).toBe('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef');
+    expect(peerInfo.onChainReputation).toBe(92);
+    expect(peerInfo.onChainSessionCount).toBe(100);
+    expect(peerInfo.onChainDisputeCount).toBe(1);
+    expect(peerInfo.trustScore).toBe(92);
+  });
+
+  it('should prefer on-chain reputation in effective reputation', () => {
+    // Simulates the _effectiveReputation logic from the router
+    function effectiveReputation(p: PeerInfo): number {
+      if (p.onChainReputation !== undefined) {
+        return p.onChainReputation;
+      }
+      return p.trustScore ?? p.reputationScore ?? 0;
+    }
+
+    const peer: PeerInfo = {
+      peerId: 'a'.repeat(64) as any,
+      lastSeen: Date.now(),
+      providers: ['anthropic'],
+      onChainReputation: 88,
+      trustScore: 70,
+      reputationScore: 60,
+    };
+
+    expect(effectiveReputation(peer)).toBe(88);
+  });
+
+  it('should fall back when on-chain reputation is not available', () => {
+    function effectiveReputation(p: PeerInfo): number {
+      if (p.onChainReputation !== undefined) {
+        return p.onChainReputation;
+      }
+      return p.trustScore ?? p.reputationScore ?? 0;
+    }
+
+    const peerWithTrust: PeerInfo = {
+      peerId: 'a'.repeat(64) as any,
+      lastSeen: Date.now(),
+      providers: ['anthropic'],
+      trustScore: 75,
+      reputationScore: 60,
+    };
+
+    const peerWithRepOnly: PeerInfo = {
+      peerId: 'b'.repeat(64) as any,
+      lastSeen: Date.now(),
+      providers: ['openai'],
+      reputationScore: 55,
+    };
+
+    const peerWithNothing: PeerInfo = {
+      peerId: 'c'.repeat(64) as any,
+      lastSeen: Date.now(),
+      providers: ['openai'],
+    };
+
+    expect(effectiveReputation(peerWithTrust)).toBe(75);
+    expect(effectiveReputation(peerWithRepOnly)).toBe(55);
+    expect(effectiveReputation(peerWithNothing)).toBe(0);
+  });
+
+  it('should verify reputation with evmAddress via verifyReputation', async () => {
+    const { verifyReputation } = await import('../src/discovery/reputation-verifier.js');
+
+    const metadata = makeMetadata({
+      evmAddress: '0x1111111111111111111111111111111111111111',
+      onChainReputation: 80,
+      onChainSessionCount: 50,
+      onChainDisputeCount: 3,
+    });
+
+    // Mock escrow client
+    const mockEscrowClient = {
+      getReputation: async (_addr: string) => ({
+        totalWeightedScore: 4000n,
+        totalWeight: 50n,
+        sessionCount: 50,
+        disputeCount: 3,
+        weightedAverage: 80,
+      }),
+    } as any;
+
+    const result = await verifyReputation(mockEscrowClient, metadata);
+
+    expect(result.valid).toBe(true);
+    expect(result.actualReputation).toBe(80);
+    expect(result.actualSessionCount).toBe(50);
+    expect(result.actualDisputeCount).toBe(3);
+    expect(result.claimedReputation).toBe(80);
+    expect(result.claimedSessionCount).toBe(50);
+    expect(result.claimedDisputeCount).toBe(3);
+
+    // Test with mismatched data
+    const mismatchedMetadata = makeMetadata({
+      evmAddress: '0x1111111111111111111111111111111111111111',
+      onChainReputation: 90, // claimed higher than actual
+      onChainSessionCount: 50,
+      onChainDisputeCount: 3,
+    });
+
+    const mismatchResult = await verifyReputation(mockEscrowClient, mismatchedMetadata);
+    expect(mismatchResult.valid).toBe(false);
+    expect(mismatchResult.actualReputation).toBe(80);
+    expect(mismatchResult.claimedReputation).toBe(90);
+  });
+});

package/tests/request-codec.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest';
+import {
+  encodeHttpRequest,
+  decodeHttpRequest,
+  encodeHttpResponse,
+  decodeHttpResponse,
+  encodeHttpResponseChunk,
+  decodeHttpResponseChunk,
+} from '../src/proxy/request-codec.js';
+import type {
+  SerializedHttpRequest,
+  SerializedHttpResponse,
+  SerializedHttpResponseChunk,
+} from '../src/types/http.js';
+
+describe('HTTP Request codec', () => {
+  it('should round-trip a basic request', () => {
+    const req: SerializedHttpRequest = {
+      requestId: 'req-123',
+      method: 'POST',
+      path: '/v1/chat/completions',
+      headers: { 'content-type': 'application/json', authorization: 'Bearer sk-test' },
+      body: new TextEncoder().encode('{"model":"gpt-4"}'),
+    };
+
+    const encoded = encodeHttpRequest(req);
+    const decoded = decodeHttpRequest(encoded);
+
+    expect(decoded.requestId).toBe(req.requestId);
+    expect(decoded.method).toBe(req.method);
+    expect(decoded.path).toBe(req.path);
+    expect(decoded.headers).toEqual(req.headers);
+    expect(new TextDecoder().decode(decoded.body)).toBe('{"model":"gpt-4"}');
+  });
+
+  it('should handle empty headers', () => {
+    const req: SerializedHttpRequest = {
+      requestId: 'r',
+      method: 'GET',
+      path: '/',
+      headers: {},
+      body: new Uint8Array(0),
+    };
+    const decoded = decodeHttpRequest(encodeHttpRequest(req));
+    expect(decoded.headers).toEqual({});
+  });
+
+  it('should handle empty body', () => {
+    const req: SerializedHttpRequest = {
+      requestId: 'r',
+      method: 'GET',
+      path: '/health',
+      headers: {},
+      body: new Uint8Array(0),
+    };
+    const decoded = decodeHttpRequest(encodeHttpRequest(req));
+    expect(decoded.body.length).toBe(0);
+  });
+
+  it('should handle large body', () => {
+    const largeBody = new Uint8Array(100_000);
+    largeBody.fill(0x42);
+    const req: SerializedHttpRequest = {
+      requestId: 'big',
+      method: 'POST',
+      path: '/upload',
+      headers: {},
+      body: largeBody,
+    };
+    const decoded = decodeHttpRequest(encodeHttpRequest(req));
+    expect(decoded.body.length).toBe(100_000);
+    expect(decoded.body[0]).toBe(0x42);
+  });
+});
+
+describe('HTTP Response codec', () => {
+  it('should round-trip a basic response', () => {
+    const resp: SerializedHttpResponse = {
+      requestId: 'req-123',
+      statusCode: 200,
+      headers: { 'content-type': 'application/json' },
+      body: new TextEncoder().encode('{"result":"ok"}'),
+    };
+
+    const decoded = decodeHttpResponse(encodeHttpResponse(resp));
+
+    expect(decoded.requestId).toBe(resp.requestId);
+    expect(decoded.statusCode).toBe(200);
+    expect(decoded.headers).toEqual(resp.headers);
+    expect(new TextDecoder().decode(decoded.body)).toBe('{"result":"ok"}');
+  });
+
+  it('should handle 500 status code', () => {
+    const resp: SerializedHttpResponse = {
+      requestId: 'err',
+      statusCode: 500,
+      headers: {},
+      body: new TextEncoder().encode('Internal Server Error'),
+    };
+    const decoded = decodeHttpResponse(encodeHttpResponse(resp));
+    expect(decoded.statusCode).toBe(500);
+  });
+});
+
+describe('HTTP Response Chunk codec', () => {
+  it('should round-trip a chunk with done=false', () => {
+    const chunk: SerializedHttpResponseChunk = {
+      requestId: 'req-123',
+      data: new TextEncoder().encode('data: {"text":"hello"}'),
+      done: false,
+    };
+
+    const decoded = decodeHttpResponseChunk(encodeHttpResponseChunk(chunk));
+
+    expect(decoded.requestId).toBe('req-123');
+    expect(decoded.done).toBe(false);
+    expect(new TextDecoder().decode(decoded.data)).toBe('data: {"text":"hello"}');
+  });
+
+  it('should round-trip a chunk with done=true', () => {
+    const chunk: SerializedHttpResponseChunk = {
+      requestId: 'req-123',
+      data: new Uint8Array(0),
+      done: true,
+    };
+
+    const decoded = decodeHttpResponseChunk(encodeHttpResponseChunk(chunk));
+
+    expect(decoded.requestId).toBe('req-123');
+    expect(decoded.done).toBe(true);
+    expect(decoded.data.length).toBe(0);
+  });
+
+  it('should handle empty data with done=false', () => {
+    const chunk: SerializedHttpResponseChunk = {
+      requestId: 'x',
+      data: new Uint8Array(0),
+      done: false,
+    };
+    const decoded = decodeHttpResponseChunk(encodeHttpResponseChunk(chunk));
+    expect(decoded.done).toBe(false);
+    expect(decoded.data.length).toBe(0);
+  });
+});

package/tests/token-counter.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import {
+  estimateTokensFromContentLength,
+  estimateTokensFromStreamBytes,
+  estimateTokens,
+  BYTES_PER_TOKEN,
+  MIN_REQUEST_TOKENS,
+  MIN_RESPONSE_TOKENS,
+} from '../src/metering/token-counter.js';
+
+describe('estimateTokensFromContentLength', () => {
+  it('should return MIN_REQUEST_TOKENS for null content-length (request)', () => {
+    expect(estimateTokensFromContentLength(null, 'openai', 'request')).toBe(MIN_REQUEST_TOKENS);
+  });
+
+  it('should return MIN_RESPONSE_TOKENS for null content-length (response)', () => {
+    expect(estimateTokensFromContentLength(null, 'openai', 'response')).toBe(MIN_RESPONSE_TOKENS);
+  });
+
+  it('should return minimum for zero content-length', () => {
+    expect(estimateTokensFromContentLength(0, 'openai', 'request')).toBe(MIN_REQUEST_TOKENS);
+    expect(estimateTokensFromContentLength(0, 'openai', 'response')).toBe(MIN_RESPONSE_TOKENS);
+  });
+
+  it('should estimate tokens from bytes for openai', () => {
+    const bytes = 4000; // 4000 bytes / 4.0 bytes-per-token = 1000 tokens
+    const result = estimateTokensFromContentLength(bytes, 'openai', 'request');
+    expect(result).toBe(1000);
+  });
+
+  it('should estimate tokens from bytes for anthropic', () => {
+    const bytes = 4200; // 4200 bytes / 4.2 bytes-per-token = 1000 tokens
+    const result = estimateTokensFromContentLength(bytes, 'anthropic', 'request');
+    expect(result).toBe(1000);
+  });
+
+  it('should use default ratio for unknown provider', () => {
+    const bytes = 4000;
+    const result = estimateTokensFromContentLength(bytes, 'custom', 'request');
+    expect(result).toBe(1000); // 4000 / 4.0 = 1000
+  });
+
+  it('should enforce minimum for small content', () => {
+    // 10 bytes / 4.0 = 3 tokens, but minimum is MIN_REQUEST_TOKENS
+    const result = estimateTokensFromContentLength(10, 'openai', 'request');
+    expect(result).toBe(MIN_REQUEST_TOKENS);
+  });
+
+  it('should ceil the result', () => {
+    // 5 bytes / 4.0 = 1.25, ceil = 2, but min = 100
+    // Let's use a larger value: 4001 / 4.0 = 1000.25, ceil = 1001
+    const result = estimateTokensFromContentLength(4001, 'openai', 'request');
+    expect(result).toBe(1001);
+  });
+});
+
+describe('estimateTokensFromStreamBytes', () => {
+  it('should return MIN_RESPONSE_TOKENS for zero bytes', () => {
+    expect(estimateTokensFromStreamBytes(0, 'openai')).toBe(MIN_RESPONSE_TOKENS);
+  });
+
+  it('should account for SSE overhead (0.82 factor)', () => {
+    const totalBytes = 10000;
+    const contentBytes = totalBytes * 0.82;
+    const expected = Math.max(Math.ceil(contentBytes / 4.0), MIN_RESPONSE_TOKENS);
+    expect(estimateTokensFromStreamBytes(totalBytes, 'openai')).toBe(expected);
+  });
+
+  it('should use provider-specific ratio', () => {
+    const totalBytes = 10000;
+    const contentBytes = totalBytes * 0.82;
+    const ratio = BYTES_PER_TOKEN['anthropic']!;
+    const expected = Math.max(Math.ceil(contentBytes / ratio), MIN_RESPONSE_TOKENS);
+    expect(estimateTokensFromStreamBytes(totalBytes, 'anthropic')).toBe(expected);
+  });
+});
+
+describe('estimateTokens', () => {
+  it('should use content-length for non-streaming response', () => {
+    const result = estimateTokens(4000, 8000, 'openai', false);
+    expect(result.method).toBe('content-length');
+    expect(result.confidence).toBe('high');
+    expect(result.inputTokens).toBe(1000);
+    expect(result.outputTokens).toBe(2000);
+    expect(result.totalTokens).toBe(3000);
+  });
+
+  it('should use chunk-accumulation for streaming response', () => {
+    const result = estimateTokens(4000, null, 'openai', true, 10000);
+    expect(result.method).toBe('chunk-accumulation');
+    expect(result.confidence).toBe('medium');
+    expect(result.inputTokens).toBe(1000);
+  });
+
+  it('should use fallback when no response info available', () => {
+    const result = estimateTokens(null, null, 'openai', false);
+    expect(result.method).toBe('fallback');
+    expect(result.confidence).toBe('low');
+    expect(result.inputTokens).toBe(MIN_REQUEST_TOKENS);
+    expect(result.outputTokens).toBe(MIN_RESPONSE_TOKENS);
+  });
+
+  it('should compute totalTokens as input + output', () => {
+    const result = estimateTokens(4000, 4000, 'openai', false);
+    expect(result.totalTokens).toBe(result.inputTokens + result.outputTokens);
+  });
+});
+
+describe('constants', () => {
+  it('should have BYTES_PER_TOKEN for known providers', () => {
+    expect(BYTES_PER_TOKEN['anthropic']).toBeDefined();
+    expect(BYTES_PER_TOKEN['openai']).toBeDefined();
+    expect(BYTES_PER_TOKEN['google']).toBeDefined();
+    expect(BYTES_PER_TOKEN['moonshot']).toBeDefined();
+    expect(BYTES_PER_TOKEN['default']).toBeDefined();
+  });
+
+  it('should have reasonable MIN token values', () => {
+    expect(MIN_REQUEST_TOKENS).toBe(100);
+    expect(MIN_RESPONSE_TOKENS).toBe(10);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts', 'src/**/*.test.ts'],
+  },
+});