@antseed/provider-core 0.1.0 → 0.1.2

package/src/http-relay.test.ts

@@ -1,269 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { HttpRelay, type RelayConfig, type RelayCallbacks } from './http-relay.js';
-import type { SerializedHttpRequest, SerializedHttpResponse } from '@antseed/node';
-
-function makeRequest(overrides?: Partial<SerializedHttpRequest>): SerializedHttpRequest {
-  return {
-    requestId: 'req-1',
-    method: 'POST',
-    path: '/v1/messages',
-    headers: { 'content-type': 'application/json' },
-    body: new TextEncoder().encode(JSON.stringify({ model: 'claude-sonnet-4-20250514', messages: [] })),
-    ...overrides,
-  };
-}
-
-function makeConfig(overrides?: Partial<RelayConfig>): RelayConfig {
-  return {
-    baseUrl: 'https://api.example.com',
-    authHeaderName: 'x-api-key',
-    authHeaderValue: 'sk-test-key',
-    maxConcurrency: 2,
-    allowedModels: ['claude-sonnet-4-20250514'],
-    ...overrides,
-  };
-}
-
-describe('HttpRelay', () => {
-  let fetchMock: ReturnType<typeof vi.fn>;
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    fetchMock = vi.fn();
-    globalThis.fetch = fetchMock;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it('relays a successful non-streaming response', async () => {
-    const responseBody = JSON.stringify({ id: 'msg_1', content: [{ text: 'Hello' }] });
-    fetchMock.mockResolvedValueOnce(new Response(responseBody, {
-      status: 200,
-      headers: { 'content-type': 'application/json', 'request-id': 'upstream-1' },
-    }));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    await relay.handleRequest(makeRequest());
-
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.statusCode).toBe(200);
-    expect(responses[0]!.requestId).toBe('req-1');
-    expect(responses[0]!.headers['content-type']).toBe('application/json');
-
-    // Verify fetch was called with the right URL and auth
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, opts] = fetchMock.mock.calls[0] as [string, RequestInit];
-    expect(url).toBe('https://api.example.com/v1/messages');
-    expect((opts.headers as Record<string, string>)['x-api-key']).toBe('sk-test-key');
-  });
-
-  it('rejects disallowed model', async () => {
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    const req = makeRequest({
-      body: new TextEncoder().encode(JSON.stringify({ model: 'gpt-4', messages: [] })),
-    });
-    await relay.handleRequest(req);
-
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.statusCode).toBe(403);
-    const body = JSON.parse(new TextDecoder().decode(responses[0]!.body)) as { error: string };
-    expect(body.error).toContain('not in the allowed list');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('allows any model when allowedModels is empty', async () => {
-    fetchMock.mockResolvedValueOnce(new Response('{}', { status: 200 }));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig({ allowedModels: [] }), callbacks);
-    const req = makeRequest({
-      body: new TextEncoder().encode(JSON.stringify({ model: 'any-model', messages: [] })),
-    });
-    await relay.handleRequest(req);
-
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.statusCode).toBe(200);
-  });
-
-  it('enforces concurrency limit', async () => {
-    // Create a fetch that blocks until we resolve it
-    let resolveFirst!: (value: Response) => void;
-    const firstFetch = new Promise<Response>((resolve) => { resolveFirst = resolve; });
-
-    fetchMock.mockReturnValueOnce(firstFetch);
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig({ maxConcurrency: 1 }), callbacks);
-
-    // Start first request (fills concurrency) — do NOT await
-    const p1 = relay.handleRequest(makeRequest({ requestId: 'req-1' }));
-
-    // Yield to allow the first handleRequest to progress to its await
-    await new Promise((r) => setTimeout(r, 0));
-
-    // Active count should be 1 now
-    expect(relay.getActiveCount()).toBe(1);
-
-    // Second request should be rejected (concurrency full)
-    await relay.handleRequest(makeRequest({ requestId: 'req-2' }));
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.requestId).toBe('req-2');
-    expect(responses[0]!.statusCode).toBe(429);
-
-    // Complete first request
-    resolveFirst(new Response('{}', { status: 200 }));
-    await p1;
-    expect(responses).toHaveLength(2);
-    expect(responses[1]!.requestId).toBe('req-1');
-    expect(responses[1]!.statusCode).toBe(200);
-
-    // Now concurrency is free, third request should work
-    fetchMock.mockResolvedValueOnce(new Response('{}', { status: 200 }));
-    await relay.handleRequest(makeRequest({ requestId: 'req-3' }));
-    expect(responses).toHaveLength(3);
-    expect(responses[2]!.requestId).toBe('req-3');
-    expect(responses[2]!.statusCode).toBe(200);
-  });
-
-  it('strips hop-by-hop and internal headers from request', async () => {
-    fetchMock.mockResolvedValueOnce(new Response('{}', { status: 200 }));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    await relay.handleRequest(makeRequest({
-      headers: {
-        'content-type': 'application/json',
-        'connection': 'keep-alive',
-        'x-antseed-provider': 'anthropic',
-        'host': 'localhost:3000',
-        'x-custom': 'keep-me',
-      },
-    }));
-
-    const [, opts] = fetchMock.mock.calls[0] as [string, RequestInit];
-    const sentHeaders = opts.headers as Record<string, string>;
-    expect(sentHeaders['connection']).toBeUndefined();
-    expect(sentHeaders['x-antseed-provider']).toBeUndefined();
-    expect(sentHeaders['host']).toBeUndefined();
-    expect(sentHeaders['x-custom']).toBe('keep-me');
-  });
-
-  it('uses tokenProvider when present', async () => {
-    fetchMock.mockResolvedValueOnce(new Response('{}', { status: 200 }));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const tokenProvider = {
-      getToken: vi.fn().mockResolvedValue('fresh-token'),
-      stop: vi.fn(),
-    };
-
-    const relay = new HttpRelay(
-      makeConfig({
-        authHeaderName: 'authorization',
-        authHeaderValue: 'Bearer old-token',
-        tokenProvider,
-      }),
-      callbacks,
-    );
-
-    await relay.handleRequest(makeRequest());
-
-    expect(tokenProvider.getToken).toHaveBeenCalledOnce();
-    const [, opts] = fetchMock.mock.calls[0] as [string, RequestInit];
-    const sentHeaders = opts.headers as Record<string, string>;
-    expect(sentHeaders['authorization']).toBe('Bearer fresh-token');
-  });
-
-  it('returns 502 on fetch failure', async () => {
-    fetchMock.mockRejectedValueOnce(new Error('Connection refused'));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    await relay.handleRequest(makeRequest());
-
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.statusCode).toBe(502);
-    const body = JSON.parse(new TextDecoder().decode(responses[0]!.body)) as { error: string };
-    expect(body.error).toContain('Connection refused');
-  });
-
-  it('accumulates SSE response into complete body', async () => {
-    const sseChunks = [
-      'event: message\ndata: {"text":"Hello"}\n\n',
-      'event: message\ndata: {"text":"World"}\n\n',
-    ];
-    const stream = new ReadableStream({
-      start(controller) {
-        for (const chunk of sseChunks) {
-          controller.enqueue(new TextEncoder().encode(chunk));
-        }
-        controller.close();
-      },
-    });
-
-    fetchMock.mockResolvedValueOnce(new Response(stream, {
-      status: 200,
-      headers: { 'content-type': 'text/event-stream' },
-    }));
-
-    const responses: SerializedHttpResponse[] = [];
-    const callbacks: RelayCallbacks = {
-      onResponse: (res) => responses.push(res),
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    await relay.handleRequest(makeRequest());
-
-    expect(responses).toHaveLength(1);
-    expect(responses[0]!.statusCode).toBe(200);
-    const bodyText = new TextDecoder().decode(responses[0]!.body);
-    expect(bodyText).toContain('Hello');
-    expect(bodyText).toContain('World');
-  });
-
-  it('tracks active count correctly', async () => {
-    fetchMock.mockResolvedValue(new Response('{}', { status: 200 }));
-
-    const callbacks: RelayCallbacks = {
-      onResponse: () => {},
-    };
-
-    const relay = new HttpRelay(makeConfig(), callbacks);
-    expect(relay.getActiveCount()).toBe(0);
-
-    await relay.handleRequest(makeRequest());
-    expect(relay.getActiveCount()).toBe(0); // decremented after completion
-  });
-});

package/src/http-relay.ts

@@ -1,187 +0,0 @@
-import type { TokenProvider } from '@antseed/node';
-import type { SerializedHttpRequest, SerializedHttpResponse, SerializedHttpResponseChunk } from '@antseed/node';
-import { swapAuthHeader, validateRequestModel } from './auth-swap.js';
-
-/** Hop-by-hop headers that must not be forwarded. */
-const HOP_BY_HOP_HEADERS = new Set([
-  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
-  'te', 'trailers', 'transfer-encoding', 'upgrade',
-]);
-
-/** Internal headers used only within Antseed routing. */
-const INTERNAL_HEADERS = new Set([
-  'x-antseed-provider',
-]);
-
-export interface RelayConfig {
-  baseUrl: string;
-  authHeaderName: string;
-  authHeaderValue: string;
-  tokenProvider?: TokenProvider;
-  extraHeaders?: Record<string, string>;
-  maxConcurrency: number;
-  allowedModels: string[];
-  timeoutMs?: number;
-}
-
-export interface RelayCallbacks {
-  onResponse: (response: SerializedHttpResponse) => void;
-  onResponseChunk?: (chunk: SerializedHttpResponseChunk) => void;
-}
-
-export class HttpRelay {
-  private readonly _config: RelayConfig;
-  private readonly _callbacks: RelayCallbacks;
-  private _activeCount = 0;
-
-  constructor(config: RelayConfig, callbacks: RelayCallbacks) {
-    this._config = config;
-    this._callbacks = callbacks;
-  }
-
-  getActiveCount(): number {
-    return this._activeCount;
-  }
-
-  private _sendError(requestId: string, statusCode: number, error: string): void {
-    this._callbacks.onResponse({
-      requestId,
-      statusCode,
-      headers: { 'content-type': 'application/json' },
-      body: new TextEncoder().encode(JSON.stringify({ error })),
-    });
-  }
-
-  async handleRequest(request: SerializedHttpRequest): Promise<void> {
-    // Validate model against allowedModels
-    const validationError = validateRequestModel(request, this._config.allowedModels);
-    if (validationError) {
-      this._sendError(request.requestId, 403, validationError);
-      return;
-    }
-
-    // Check concurrency
-    if (this._activeCount >= this._config.maxConcurrency) {
-      this._sendError(request.requestId, 429, 'Max concurrency reached');
-      return;
-    }
-
-    // Increment active count
-    this._activeCount++;
-
-    try {
-      // Resolve dynamic auth token if provider uses OAuth / keychain
-      let effectiveConfig: { authHeaderName: string; authHeaderValue: string; extraHeaders?: Record<string, string> } = {
-        authHeaderName: this._config.authHeaderName,
-        authHeaderValue: this._config.authHeaderValue,
-        extraHeaders: this._config.extraHeaders,
-      };
-      if (this._config.tokenProvider) {
-        const freshToken = await this._config.tokenProvider.getToken();
-        // Preserve Bearer prefix for OAuth providers that use Authorization header
-        const isBearer = this._config.authHeaderName === 'authorization';
-        const headerValue = isBearer ? `Bearer ${freshToken}` : freshToken;
-        effectiveConfig = { ...effectiveConfig, authHeaderValue: headerValue };
-      }
-
-      // Swap auth headers
-      const swappedRequest = swapAuthHeader(request, effectiveConfig);
-
-      // Build upstream URL
-      const base = this._config.baseUrl.replace(/\/+$/, '');
-      const path = request.path.startsWith('/') ? request.path : `/${request.path}`;
-      const url = `${base}${path}`;
-
-      // Build fetch headers, stripping hop-by-hop
-      const fetchHeaders: Record<string, string> = {};
-      for (const [key, value] of Object.entries(swappedRequest.headers)) {
-        const lower = key.toLowerCase();
-        if (!HOP_BY_HOP_HEADERS.has(lower) && !INTERNAL_HEADERS.has(lower) && lower !== 'host' && lower !== 'content-length' && lower !== 'accept-encoding') {
-          fetchHeaders[key] = value;
-        }
-      }
-
-      const timeoutMs = this._config.timeoutMs ?? 120_000;
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), timeoutMs);
-      let fetchResponse: Response;
-      try {
-        fetchResponse = await fetch(url, {
-          method: swappedRequest.method,
-          headers: fetchHeaders,
-          body: swappedRequest.method !== 'GET' && swappedRequest.method !== 'HEAD'
-            ? Buffer.from(swappedRequest.body)
-            : undefined,
-          signal: controller.signal,
-        });
-      } finally {
-        clearTimeout(timeout);
-      }
-
-      const contentType = fetchResponse.headers.get('content-type') ?? '';
-      const isSSE = contentType.includes('text/event-stream');
-
-      // Build response headers, stripping hop-by-hop and encoding headers.
-      // Node.js fetch auto-decompresses gzip/br responses, so we must strip
-      // content-encoding to prevent the client from double-decompressing.
-      const responseHeaders: Record<string, string> = {};
-      fetchResponse.headers.forEach((value, key) => {
-        const lower = key.toLowerCase();
-        if (!HOP_BY_HOP_HEADERS.has(lower) && lower !== 'content-encoding' && lower !== 'content-length') {
-          responseHeaders[lower] = value;
-        }
-      });
-
-      if (isSSE && fetchResponse.body) {
-        // Accumulate SSE body and send as a complete response so that
-        // upstream response headers (request-id, usage metadata, etc.)
-        // are preserved for the buyer.
-        const reader = fetchResponse.body.getReader();
-        const chunks: Uint8Array[] = [];
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            chunks.push(value);
-          }
-        } catch (err) {
-          chunks.push(
-            new TextEncoder().encode(
-              `event: error\ndata: ${err instanceof Error ? err.message : 'stream error'}\n\n`
-            ),
-          );
-        }
-
-        const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-        const body = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const c of chunks) {
-          body.set(c, offset);
-          offset += c.length;
-        }
-
-        this._callbacks.onResponse({
-          requestId: request.requestId,
-          statusCode: fetchResponse.status,
-          headers: responseHeaders,
-          body,
-        });
-      } else {
-        // Complete response
-        const body = new Uint8Array(await fetchResponse.arrayBuffer());
-        this._callbacks.onResponse({
-          requestId: request.requestId,
-          statusCode: fetchResponse.status,
-          headers: responseHeaders,
-          body,
-        });
-      }
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      const sanitized = errMsg.replace(/sk-ant-[a-zA-Z0-9_-]+/g, 'sk-***');
-      this._sendError(request.requestId, 502, `Upstream error: ${sanitized}`);
-    } finally {
-      this._activeCount--;
-    }
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export { HttpRelay, type RelayConfig, type RelayCallbacks } from './http-relay.js';
-export { swapAuthHeader, validateRequestModel, KNOWN_AUTH_HEADERS } from './auth-swap.js';
-export { StaticTokenProvider, OAuthTokenProvider, createTokenProvider, type AuthType } from './token-providers.js';
-export type { TokenProvider, TokenProviderState } from './token-providers.js';
-export { BaseProvider, type BaseProviderConfig } from './base-provider.js';

package/src/token-providers.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { StaticTokenProvider, OAuthTokenProvider, createTokenProvider } from './token-providers.js';
-
-describe('StaticTokenProvider', () => {
-  it('returns the static token', async () => {
-    const provider = new StaticTokenProvider('sk-test-key');
-    const token = await provider.getToken();
-    expect(token).toBe('sk-test-key');
-  });
-
-  it('returns the same token on multiple calls', async () => {
-    const provider = new StaticTokenProvider('sk-test-key');
-    expect(await provider.getToken()).toBe('sk-test-key');
-    expect(await provider.getToken()).toBe('sk-test-key');
-  });
-
-  it('getState returns token state', () => {
-    const provider = new StaticTokenProvider('sk-test-key');
-    expect(provider.getState()).toEqual({ accessToken: 'sk-test-key' });
-  });
-
-  it('stop is a no-op', () => {
-    const provider = new StaticTokenProvider('sk-test-key');
-    expect(() => provider.stop()).not.toThrow();
-  });
-});
-
-describe('OAuthTokenProvider', () => {
-  let fetchMock: ReturnType<typeof vi.fn>;
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    fetchMock = vi.fn();
-    globalThis.fetch = fetchMock;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it('returns access token when not expired', async () => {
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() + 60 * 60 * 1000, // 1 hour from now
-    });
-
-    const token = await provider.getToken();
-    expect(token).toBe('access-1');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('refreshes token when expired', async () => {
-    fetchMock.mockResolvedValueOnce(new Response(
-      JSON.stringify({
-        access_token: 'access-2',
-        refresh_token: 'refresh-2',
-        expires_in: 3600,
-      }),
-      { status: 200 },
-    ));
-
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() - 1000, // already expired
-    });
-
-    const token = await provider.getToken();
-    expect(token).toBe('access-2');
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('refreshes when within 5 minute buffer', async () => {
-    fetchMock.mockResolvedValueOnce(new Response(
-      JSON.stringify({
-        access_token: 'access-refreshed',
-        expires_in: 3600,
-      }),
-      { status: 200 },
-    ));
-
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-old',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() + 2 * 60 * 1000, // 2 minutes from now (within 5 min buffer)
-    });
-
-    const token = await provider.getToken();
-    expect(token).toBe('access-refreshed');
-  });
-
-  it('deduplicates concurrent refresh calls', async () => {
-    let resolveRefresh!: (value: Response) => void;
-    const refreshPromise = new Promise<Response>((resolve) => { resolveRefresh = resolve; });
-    fetchMock.mockReturnValueOnce(refreshPromise);
-
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() - 1000,
-    });
-
-    // Start two concurrent getToken calls
-    const p1 = provider.getToken();
-    const p2 = provider.getToken();
-
-    resolveRefresh(new Response(
-      JSON.stringify({ access_token: 'access-new', expires_in: 3600 }),
-      { status: 200 },
-    ));
-
-    const [t1, t2] = await Promise.all([p1, p2]);
-    expect(t1).toBe('access-new');
-    expect(t2).toBe('access-new');
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('throws on refresh failure', async () => {
-    fetchMock.mockResolvedValueOnce(new Response('Unauthorized', { status: 401 }));
-
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() - 1000,
-    });
-
-    await expect(provider.getToken()).rejects.toThrow('OAuth refresh failed (401)');
-  });
-
-  it('getState returns current state', () => {
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: 1234567890,
-    });
-
-    const state = provider.getState();
-    expect(state).toEqual({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: 1234567890,
-    });
-  });
-
-  it('updates refresh token when provided in response', async () => {
-    fetchMock.mockResolvedValueOnce(new Response(
-      JSON.stringify({
-        access_token: 'access-2',
-        refresh_token: 'refresh-2',
-        expires_in: 3600,
-      }),
-      { status: 200 },
-    ));
-
-    const provider = new OAuthTokenProvider({
-      accessToken: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() - 1000,
-    });
-
-    await provider.getToken();
-    const state = provider.getState();
-    expect(state.refreshToken).toBe('refresh-2');
-  });
-});
-
-describe('createTokenProvider', () => {
-  it('creates StaticTokenProvider for apikey type', () => {
-    const provider = createTokenProvider({ authType: 'apikey', authValue: 'sk-key' });
-    expect(provider).toBeInstanceOf(StaticTokenProvider);
-  });
-
-  it('defaults to StaticTokenProvider when authType is omitted', () => {
-    const provider = createTokenProvider({ authValue: 'sk-key' });
-    expect(provider).toBeInstanceOf(StaticTokenProvider);
-  });
-
-  it('creates OAuthTokenProvider for oauth type with refresh token', () => {
-    const provider = createTokenProvider({
-      authType: 'oauth',
-      authValue: 'access-1',
-      refreshToken: 'refresh-1',
-      expiresAt: Date.now() + 3600_000,
-    });
-    expect(provider).toBeInstanceOf(OAuthTokenProvider);
-  });
-
-  it('creates StaticTokenProvider for oauth type without refresh token', () => {
-    const provider = createTokenProvider({
-      authType: 'oauth',
-      authValue: 'access-1',
-    });
-    expect(provider).toBeInstanceOf(StaticTokenProvider);
-  });
-});