@antseed/node 0.1.0 → 0.1.2

package/tests/receipt.test.ts

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

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

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

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

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

package/vitest.config.ts

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