@antseed/node 0.1.0 → 0.1.1

package/src/payments/evm/escrow-client.ts

@@ -1,263 +0,0 @@
-import { Contract, JsonRpcProvider, type AbstractSigner } from 'ethers';
-
-export interface BaseEscrowConfig {
-  /** Base JSON-RPC endpoint (e.g. http://127.0.0.1:8545 for anvil) */
-  rpcUrl: string;
-  /** Deployed AntseedEscrow contract address */
-  contractAddress: string;
-  /** USDC token contract address */
-  usdcAddress: string;
-  /** Confirmation commitment level (not used on EVM, reserved for future) */
-  commitment?: 'latest' | 'finalized';
-}
-
-export interface SessionInfo {
-  buyer: string;
-  seller: string;
-  lockedAmount: bigint;
-  status: number;
-  expiresAt: number;
-  settledAmount: bigint;
-  score: number;
-  disputeClaimedAmount: bigint;
-  disputeOpenedAt: number;
-  disputeBuyerResponded: boolean;
-}
-
-export interface ReputationInfo {
-  totalWeightedScore: bigint;
-  totalWeight: bigint;
-  sessionCount: number;
-  disputeCount: number;
-  weightedAverage: number;
-}
-
-const ESCROW_ABI = [
-  // Deposit & Withdraw
-  'function deposit(uint256 amount) external',
-  'function withdraw(uint256 amount) external',
-
-  // Session lifecycle
-  'function commitLock(bytes32 sessionId, address buyer, uint256 amount, bytes calldata buyerSig) external',
-  'function extendLock(bytes32 sessionId, uint256 additionalAmount, bytes calldata buyerSig) external',
-  'function settle(bytes32 sessionId, uint256 runningTotal, uint8 score, bytes calldata buyerSig) external',
-
-  // Disputes
-  'function openDispute(bytes32 sessionId, uint256 claimedAmount) external',
-  'function respondDispute(bytes32 sessionId) external',
-  'function resolveDispute(bytes32 sessionId) external',
-
-  // Expired lock
-  'function releaseExpiredLock(bytes32 sessionId) external',
-
-  // View functions
-  'function buyers(address) external view returns (uint256 deposited, uint256 committed)',
-  'function sessions(bytes32) external view returns (address buyer, address seller, uint256 lockedAmount, uint8 status, uint64 expiresAt, uint256 settledAmount, uint8 score, uint256 disputeClaimedAmount, uint64 disputeOpenedAt, bool disputeBuyerResponded, bool exists)',
-  'function reputations(address) external view returns (uint256 totalWeightedScore, uint256 totalWeight, uint256 sessionCount, uint256 disputeCount)',
-] as const;
-
-const ERC20_ABI = [
-  'function approve(address spender, uint256 amount) external returns (bool)',
-  'function balanceOf(address owner) external view returns (uint256)',
-  'function allowance(address owner, address spender) external view returns (uint256)',
-] as const;
-
-export class BaseEscrowClient {
-  private readonly _provider: JsonRpcProvider;
-  private readonly _contractAddress: string;
-  private readonly _usdcAddress: string;
-  private readonly _nonceCursor = new Map<string, number>();
-
-  constructor(config: BaseEscrowConfig) {
-    this._provider = new JsonRpcProvider(config.rpcUrl);
-    this._contractAddress = config.contractAddress;
-    this._usdcAddress = config.usdcAddress;
-  }
-
-  get provider(): JsonRpcProvider { return this._provider; }
-  get contractAddress(): string { return this._contractAddress; }
-  get usdcAddress(): string { return this._usdcAddress; }
-
-  private _ensureConnected(signer: AbstractSigner): AbstractSigner {
-    if (signer.provider) {
-      return signer;
-    }
-    return signer.connect(this._provider);
-  }
-
-  private async reserveNonce(address: string): Promise<number> {
-    const networkNonce = await this._provider.getTransactionCount(address, 'pending');
-    const cachedNext = this._nonceCursor.get(address);
-    const nonce = cachedNext === undefined ? networkNonce : Math.max(networkNonce, cachedNext);
-    this._nonceCursor.set(address, nonce + 1);
-    return nonce;
-  }
-
-  private async _prepareEscrowWrite(signer: AbstractSigner): Promise<{
-    contract: Contract;
-    nonce: number;
-  }> {
-    const connected = this._ensureConnected(signer);
-    const signerAddress = await connected.getAddress();
-    const nonce = await this.reserveNonce(signerAddress);
-    const contract = new Contract(this._contractAddress, ESCROW_ABI, connected);
-    return { contract, nonce };
-  }
-
-  async deposit(signer: AbstractSigner, amount: bigint): Promise<string> {
-    const connected = this._ensureConnected(signer);
-    const signerAddress = await connected.getAddress();
-    const usdc = new Contract(this._usdcAddress, ERC20_ABI, connected);
-    const approveNonce = await this.reserveNonce(signerAddress);
-    const approveTx = await usdc.getFunction('approve')(this._contractAddress, amount, { nonce: approveNonce });
-    await approveTx.wait();
-    const contract = new Contract(this._contractAddress, ESCROW_ABI, connected);
-    const depositNonce = await this.reserveNonce(signerAddress);
-    const tx = await contract.getFunction('deposit')(amount, { nonce: depositNonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async withdraw(signer: AbstractSigner, amount: bigint): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(signer);
-    const tx = await contract.getFunction('withdraw')(amount, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async commitLock(
-    seller: AbstractSigner,
-    buyerAddr: string,
-    sessionId: string,
-    amount: bigint,
-    buyerSig: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(seller);
-    const tx = await contract.getFunction('commitLock')(sessionId, buyerAddr, amount, buyerSig, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async extendLock(
-    seller: AbstractSigner,
-    sessionId: string,
-    additionalAmount: bigint,
-    buyerSig: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(seller);
-    const tx = await contract.getFunction('extendLock')(sessionId, additionalAmount, buyerSig, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async settle(
-    seller: AbstractSigner,
-    sessionId: string,
-    runningTotal: bigint,
-    score: number,
-    buyerSig: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(seller);
-    const tx = await contract.getFunction('settle')(sessionId, runningTotal, score, buyerSig, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async openDispute(
-    caller: AbstractSigner,
-    sessionId: string,
-    claimedAmount: bigint,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(caller);
-    const tx = await contract.getFunction('openDispute')(sessionId, claimedAmount, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async respondDispute(
-    buyer: AbstractSigner,
-    sessionId: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(buyer);
-    const tx = await contract.getFunction('respondDispute')(sessionId, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async resolveDispute(
-    caller: AbstractSigner,
-    sessionId: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(caller);
-    const tx = await contract.getFunction('resolveDispute')(sessionId, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async releaseExpiredLock(
-    buyer: AbstractSigner,
-    sessionId: string,
-  ): Promise<string> {
-    const { contract, nonce } = await this._prepareEscrowWrite(buyer);
-    const tx = await contract.getFunction('releaseExpiredLock')(sessionId, { nonce });
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-
-  async getBuyerAccount(buyerAddr: string): Promise<{
-    deposited: bigint;
-    committed: bigint;
-    available: bigint;
-  }> {
-    const contract = new Contract(this._contractAddress, ESCROW_ABI, this._provider);
-    const result = await contract.getFunction('buyers')(buyerAddr);
-    const deposited = result[0] as bigint;
-    const committed = result[1] as bigint;
-    return {
-      deposited,
-      committed,
-      available: deposited - committed,
-    };
-  }
-
-  async getSession(sessionId: string): Promise<SessionInfo> {
-    const contract = new Contract(this._contractAddress, ESCROW_ABI, this._provider);
-    const result = await contract.getFunction('sessions')(sessionId);
-    return {
-      buyer: result[0],
-      seller: result[1],
-      lockedAmount: result[2],
-      status: Number(result[3]),
-      expiresAt: Number(result[4]),
-      settledAmount: result[5],
-      score: Number(result[6]),
-      disputeClaimedAmount: result[7],
-      disputeOpenedAt: Number(result[8]),
-      disputeBuyerResponded: result[9],
-    };
-  }
-
-  async getReputation(sellerAddr: string): Promise<ReputationInfo> {
-    const contract = new Contract(this._contractAddress, ESCROW_ABI, this._provider);
-    const result = await contract.getFunction('reputations')(sellerAddr);
-    const totalWeightedScore = result[0] as bigint;
-    const totalWeight = result[1] as bigint;
-    const sessionCount = Number(result[2]);
-    const disputeCount = Number(result[3]);
-    const weightedAverage = totalWeight > 0n
-      ? Number(totalWeightedScore / totalWeight)
-      : 50;
-    return {
-      totalWeightedScore,
-      totalWeight,
-      sessionCount,
-      disputeCount,
-      weightedAverage,
-    };
-  }
-
-  async getUSDCBalance(ownerAddr: string): Promise<bigint> {
-    const usdc = new Contract(this._usdcAddress, ERC20_ABI, this._provider);
-    return usdc.getFunction('balanceOf')(ownerAddr) as Promise<bigint>;
-  }
-}

package/src/payments/evm/keypair.ts

@@ -1,31 +0,0 @@
-import { Wallet, keccak256 } from 'ethers';
-import type { Identity } from '../../p2p/identity.js';
-
-/**
- * Derive a secp256k1 private key from the Ed25519 identity seed.
- * Domain-separated to ensure the derived key is independent from the Ed25519 key.
- *
- * Derivation: keccak256(ed25519_seed || "evm-payment-key") → secp256k1 private key
- *
- * The Ed25519 seed (identity.privateKey) is 32 bytes. We append a fixed
- * domain separator string to prevent the derived key from colliding with
- * any other use of the same seed. keccak256 produces a 32-byte output
- * which is a valid secp256k1 private key (the probability of hitting an
- * invalid key is astronomically low: ~1/2^128).
- */
-export function identityToEvmWallet(identity: Identity): Wallet {
-  const domainSeparator = new TextEncoder().encode('evm-payment-key');
-  const combined = new Uint8Array(identity.privateKey.length + domainSeparator.length);
-  combined.set(identity.privateKey, 0);
-  combined.set(domainSeparator, identity.privateKey.length);
-  const privateKey = keccak256(combined);
-  return new Wallet(privateKey);
-}
-
-/**
- * Get the EVM address (0x-prefixed hex) for a Antseed Identity.
- * This is the address that appears on-chain as the buyer or seller.
- */
-export function identityToEvmAddress(identity: Identity): string {
-  return identityToEvmWallet(identity).address;
-}

package/src/payments/evm/signatures.ts

@@ -1,103 +0,0 @@
-import { type AbstractSigner, solidityPackedKeccak256, getBytes } from 'ethers';
-import type { Identity } from '../../p2p/identity.js';
-import { signData, verifySignature } from '../../p2p/identity.js';
-
-// =========================================================================
-// ECDSA signatures (on-chain) — verified by contract via ecrecover
-// =========================================================================
-
-export function buildLockMessageHash(
-  sessionId: string,
-  seller: string,
-  amount: bigint,
-): string {
-  return solidityPackedKeccak256(
-    ['bytes1', 'bytes32', 'address', 'uint256'],
-    ['0x01', sessionId, seller, amount],
-  );
-}
-
-export function buildSettlementMessageHash(
-  sessionId: string,
-  runningTotal: bigint,
-  score: number,
-): string {
-  return solidityPackedKeccak256(
-    ['bytes32', 'uint256', 'uint8'],
-    [sessionId, runningTotal, score],
-  );
-}
-
-export function buildExtendLockMessageHash(
-  sessionId: string,
-  seller: string,
-  additionalAmount: bigint,
-): string {
-  return solidityPackedKeccak256(
-    ['bytes1', 'bytes32', 'address', 'uint256'],
-    ['0x02', sessionId, seller, additionalAmount],
-  );
-}
-
-export async function signMessageEcdsa(
-  signer: AbstractSigner,
-  messageHash: string,
-): Promise<string> {
-  return signer.signMessage(getBytes(messageHash));
-}
-
-// =========================================================================
-// Ed25519 signatures (off-chain P2P) — bilateral receipt proof
-// =========================================================================
-
-export function buildReceiptMessage(
-  sessionId: Uint8Array,
-  runningTotal: bigint,
-  requestCount: number,
-  responseHash: Uint8Array,
-): Uint8Array {
-  if (sessionId.length !== 32) throw new Error(`sessionId must be 32 bytes, got ${sessionId.length}`);
-  if (responseHash.length !== 32) throw new Error(`responseHash must be 32 bytes, got ${responseHash.length}`);
-  const msg = new Uint8Array(76);
-  msg.set(sessionId, 0);
-  const totalBuf = new ArrayBuffer(8);
-  new DataView(totalBuf).setBigUint64(0, runningTotal, true);
-  msg.set(new Uint8Array(totalBuf), 32);
-  const countBuf = new ArrayBuffer(4);
-  new DataView(countBuf).setUint32(0, requestCount, true);
-  msg.set(new Uint8Array(countBuf), 40);
-  msg.set(responseHash, 44);
-  return msg;
-}
-
-export function buildAckMessage(
-  sessionId: Uint8Array,
-  runningTotal: bigint,
-  requestCount: number,
-): Uint8Array {
-  if (sessionId.length !== 32) throw new Error(`sessionId must be 32 bytes, got ${sessionId.length}`);
-  const msg = new Uint8Array(44);
-  msg.set(sessionId, 0);
-  const totalBuf = new ArrayBuffer(8);
-  new DataView(totalBuf).setBigUint64(0, runningTotal, true);
-  msg.set(new Uint8Array(totalBuf), 32);
-  const countBuf = new ArrayBuffer(4);
-  new DataView(countBuf).setUint32(0, requestCount, true);
-  msg.set(new Uint8Array(countBuf), 40);
-  return msg;
-}
-
-export async function signMessageEd25519(
-  identity: Identity,
-  message: Uint8Array,
-): Promise<Uint8Array> {
-  return signData(identity.privateKey, message);
-}
-
-export async function verifyMessageEd25519(
-  publicKey: Uint8Array,
-  signature: Uint8Array,
-  message: Uint8Array,
-): Promise<boolean> {
-  return verifySignature(publicKey, signature, message);
-}

package/src/payments/evm/wallet.ts

@@ -1,42 +0,0 @@
-import { JsonRpcProvider, Contract, formatEther, formatUnits } from 'ethers';
-import type { Identity } from '../../p2p/identity.js';
-import type { WalletInfo, ChainId } from '../types.js';
-import { identityToEvmWallet, identityToEvmAddress } from './keypair.js';
-
-const ERC20_BALANCE_ABI = [
-  'function balanceOf(address owner) external view returns (uint256)',
-] as const;
-
-export async function getWalletInfo(
-  identity: Identity,
-  rpcUrl: string,
-  usdcAddress: string,
-  chainId: ChainId,
-): Promise<WalletInfo> {
-  const wallet = identityToEvmWallet(identity);
-  const provider = new JsonRpcProvider(rpcUrl);
-  const address = wallet.address;
-
-  const ethBalance = await provider.getBalance(address);
-  const balanceETH = formatEther(ethBalance);
-
-  const usdc = new Contract(usdcAddress, ERC20_BALANCE_ABI, provider);
-  let balanceUSDC = '0';
-  try {
-    const usdcRaw: bigint = await usdc.getFunction('balanceOf')(address);
-    balanceUSDC = formatUnits(usdcRaw, 6);
-  } catch {
-    // Contract may not exist on local dev chain yet
-  }
-
-  return {
-    address,
-    chainId,
-    balanceETH,
-    balanceUSDC,
-  };
-}
-
-export function getAddress(identity: Identity): string {
-  return identityToEvmAddress(identity);
-}

package/src/payments/index.ts

@@ -1,50 +0,0 @@
-// Payment types
-export type {
-  PaymentMethod,
-  ChainId,
-  WalletInfo,
-  TransactionType,
-  Transaction,
-  PaymentConfig,
-  CryptoPaymentConfig,
-  SettlementResult,
-  DisputeStatus,
-  PaymentDispute,
-} from './types.js';
-
-// Balance tracking (local transaction history)
-export { BalanceManager } from './balance-manager.js';
-export type { UnifiedBalance } from './balance-manager.js';
-
-// Off-chain settlement calculation
-export { calculateSettlement, isSettlementWithinEscrow, calculateRefund } from './settlement.js';
-
-// Off-chain dispute detection
-export {
-  createDispute,
-  detectDiscrepancy,
-  resolveDispute,
-  isDisputeExpired,
-  calculateDisputedAmount,
-  DISPUTE_TIMEOUT_MS,
-} from './disputes.js';
-
-// Base/EVM integration
-export { BaseEscrowClient } from './evm/escrow-client.js';
-export type { BaseEscrowConfig, SessionInfo, ReputationInfo } from './evm/escrow-client.js';
-export { identityToEvmWallet, identityToEvmAddress } from './evm/keypair.js';
-export {
-  signMessageEcdsa,
-  signMessageEd25519,
-  buildLockMessageHash,
-  buildSettlementMessageHash,
-  buildExtendLockMessageHash,
-  buildReceiptMessage,
-  buildAckMessage,
-  verifyMessageEd25519,
-} from './evm/signatures.js';
-export { getWalletInfo, getAddress } from './evm/wallet.js';
-
-// Buyer payment manager
-export { BuyerPaymentManager } from './buyer-payment-manager.js';
-export type { BuyerPaymentConfig, BuyerSessionState, BuyerSessionStatus } from './buyer-payment-manager.js';

package/src/payments/settlement.ts

@@ -1,40 +0,0 @@
-import type { UsageReceipt } from '../types/metering.js';
-import type { SettlementResult } from './types.js';
-
-export function calculateSettlement(
-  sessionId: string,
-  receipts: UsageReceipt[],
-  platformFeeRate: number,
-): SettlementResult {
-  if (platformFeeRate < 0 || platformFeeRate > 1) {
-    throw new Error(`platformFeeRate must be between 0 and 1, got ${platformFeeRate}`);
-  }
-  const matching = receipts.filter((r) => r.sessionId === sessionId);
-  const totalTokens = matching.reduce((sum, r) => sum + r.tokens.totalTokens, 0);
-  const totalCostUSD = matching.reduce((sum, r) => sum + r.costCents, 0) / 100;
-  const platformFeeUSD = totalCostUSD * platformFeeRate;
-  const sellerPayoutUSD = totalCostUSD - platformFeeUSD;
-
-  return {
-    sessionId,
-    receipts: matching,
-    totalTokens,
-    totalCostUSD,
-    platformFeeUSD,
-    sellerPayoutUSD,
-  };
-}
-
-export function isSettlementWithinEscrow(
-  settlementCostUSD: number,
-  escrowAmountUSD: number,
-): boolean {
-  return settlementCostUSD <= escrowAmountUSD;
-}
-
-export function calculateRefund(
-  escrowAmountUSD: number,
-  settlementCostUSD: number,
-): number {
-  return Math.max(0, escrowAmountUSD - settlementCostUSD);
-}

package/src/payments/types.ts

@@ -1,79 +0,0 @@
-import type { PeerId } from '../types/peer.js';
-import type { UsageReceipt } from '../types/metering.js';
-
-export type PaymentMethod = 'crypto';
-
-export type ChainId = 'base-local' | 'base-sepolia' | 'base-mainnet';
-
-export interface WalletInfo {
-  /** EVM address (0x-prefixed hex) */
-  address: string;
-  /** Base network */
-  chainId: ChainId;
-  /** ETH balance (formatted string, e.g. "0.05") — needed for gas on Base */
-  balanceETH: string;
-  /** USDC balance (formatted string, 6 decimals, e.g. "10.50") */
-  balanceUSDC: string;
-}
-
-export type TransactionType =
-  | 'escrow_lock'
-  | 'escrow_release'
-  | 'escrow_refund'
-  | 'dispute_resolution';
-
-export interface Transaction {
-  txId: string;
-  type: TransactionType;
-  amountUSD: number;
-  from: string;
-  to: string;
-  timestamp: number;
-  chainId?: ChainId;
-  txHash?: string;
-  status: 'pending' | 'confirmed' | 'failed';
-}
-
-export interface PaymentConfig {
-  crypto?: CryptoPaymentConfig;
-}
-
-export interface CryptoPaymentConfig {
-  /** Base network */
-  chainId: ChainId;
-  /** Base JSON-RPC URL (e.g. http://127.0.0.1:8545 for anvil) */
-  rpcUrl: string;
-  /** Deployed AntseedEscrow contract address */
-  contractAddress: string;
-  /** USDC token contract address */
-  usdcAddress: string;
-  /** Default lock amount for new sessions (USDC base units as string, e.g. "1000000" = 1 USDC) */
-  defaultLockAmountUSDC?: string;
-}
-
-export interface SettlementResult {
-  sessionId: string;
-  receipts: UsageReceipt[];
-  totalTokens: number;
-  totalCostUSD: number;
-  platformFeeUSD: number;
-  sellerPayoutUSD: number;
-  channelId?: string;
-  paymentTxHash?: string;
-}
-
-export type DisputeStatus = 'open' | 'resolved' | 'expired';
-
-export interface PaymentDispute {
-  disputeId: string;
-  channelId: string;
-  sessionId: string;
-  initiatorPeerId: PeerId;
-  reason: string;
-  status: DisputeStatus;
-  buyerReceipts: UsageReceipt[];
-  sellerReceipts: UsageReceipt[];
-  createdAt: number;
-  resolvedAt: number | null;
-  resolution: string | null;
-}

package/src/proxy/index.ts

@@ -1,3 +0,0 @@
-export { ProxyMux } from './proxy-mux.js';
-export { encodeHttpRequest, decodeHttpRequest, encodeHttpResponse, decodeHttpResponse, encodeHttpResponseChunk, decodeHttpResponseChunk } from './request-codec.js';
-export { detectProviderFromHeaders, detectProviderFromPath, resolveProvider, IDLEAI_PROVIDER_HEADER } from './provider-detection.js';

package/src/proxy/provider-detection.ts

@@ -1,78 +0,0 @@
-import type { ProviderType } from '../types/metering.js';
-
-export const ANTSEED_PROVIDER_HEADER = 'x-antseed-provider';
-/** @deprecated Use ANTSEED_PROVIDER_HEADER instead */
-export const IDLEAI_PROVIDER_HEADER = ANTSEED_PROVIDER_HEADER;
-
-const KNOWN_PROVIDERS = new Set<string>([
-  'anthropic',
-  'openai',
-  'google',
-  'moonshot',
-]);
-
-function getHeaderCaseInsensitive(
-  headers: Record<string, string>,
-  key: string
-): string | undefined {
-  const target = key.toLowerCase();
-  for (const [headerName, value] of Object.entries(headers)) {
-    if (headerName.toLowerCase() === target) {
-      return value;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Return the provider encoded in an internal routing header, if valid.
- */
-export function detectProviderFromHeaders(headers: Record<string, string>): ProviderType | null {
-  const raw = getHeaderCaseInsensitive(headers, ANTSEED_PROVIDER_HEADER);
-  if (!raw) {
-    return null;
-  }
-  const normalized = raw.trim().toLowerCase();
-  return KNOWN_PROVIDERS.has(normalized) ? normalized : null;
-}
-
-/**
- * Detect provider using request path heuristics.
- */
-export function detectProviderFromPath(path: string): ProviderType | null {
-  const normalizedPath = path.toLowerCase();
-
-  // Must be evaluated before OpenAI checks since moonshot can share OpenAI-style paths.
-  if (normalizedPath.includes('moonshot')) {
-    return 'moonshot';
-  }
-
-  if (normalizedPath.startsWith('/v1/messages') || normalizedPath.startsWith('/v1/complete')) {
-    return 'anthropic';
-  }
-  if (
-    normalizedPath.startsWith('/v1/chat') ||
-    normalizedPath.startsWith('/v1/completions') ||
-    normalizedPath.startsWith('/v1/embeddings')
-  ) {
-    return 'openai';
-  }
-  if (normalizedPath.startsWith('/v1beta/') || normalizedPath.startsWith('/v1/models/gemini')) {
-    return 'google';
-  }
-  return null;
-}
-
-/**
- * Resolve provider with priority:
- * 1. explicit internal header
- * 2. request path inference
- * 3. fallback value
- */
-export function resolveProvider(
-  path: string,
-  headers: Record<string, string>,
-  fallback: ProviderType
-): ProviderType {
-  return detectProviderFromHeaders(headers) ?? detectProviderFromPath(path) ?? fallback;
-}