@framers/agentos-ext-anchor-providers 1.1.0 → 1.2.1

package/src/register.ts

@@ -1,69 +0,0 @@
-/**
- * @file register.ts
- * @description Registers all anchor provider factories with the core AgentOS factory.
- * Call `registerExtensionProviders()` once at startup to enable config-driven
- * provider creation via `createAnchorProvider()`.
- *
- * @module @framers/agentos-ext-anchor-providers
- */
-
-import { registerAnchorProviderFactory } from '@framers/agentos';
-import { WormSnapshotProvider } from './providers/WormSnapshotProvider.js';
-import type { WormSnapshotProviderConfig } from './providers/WormSnapshotProvider.js';
-import { RekorProvider } from './providers/RekorProvider.js';
-import type { RekorProviderConfig } from './providers/RekorProvider.js';
-import { OpenTimestampsProvider } from './providers/OpenTimestampsProvider.js';
-import type { OpenTimestampsProviderConfig } from './providers/OpenTimestampsProvider.js';
-import { EthereumProvider } from './providers/EthereumProvider.js';
-import type { EthereumProviderConfig } from './providers/EthereumProvider.js';
-import { SolanaProvider } from './providers/SolanaProvider.js';
-import type { SolanaProviderConfig } from './providers/SolanaProvider.js';
-
-let registered = false;
-
-/**
- * Register all anchor provider factories with the core AgentOS provider registry.
- * Call once at application startup, before creating any AnchorProvider via config.
- *
- * Safe to call multiple times — subsequent calls are no-ops.
- *
- * @example
- * ```typescript
- * import { registerExtensionProviders } from '@framers/agentos-ext-anchor-providers';
- * import { createAnchorProvider } from '@framers/agentos';
- *
- * // Register at startup
- * registerExtensionProviders();
- *
- * // Now config-driven creation works:
- * const provider = createAnchorProvider({
- *   type: 'rekor',
- *   options: { serverUrl: 'https://rekor.sigstore.dev' },
- * });
- * ```
- */
-export function registerExtensionProviders(): void {
-  if (registered) return;
-
-  registerAnchorProviderFactory('worm-snapshot', (opts) =>
-    new WormSnapshotProvider(opts as unknown as WormSnapshotProviderConfig),
-  );
-
-  registerAnchorProviderFactory('rekor', (opts) =>
-    new RekorProvider(opts as unknown as RekorProviderConfig),
-  );
-
-  registerAnchorProviderFactory('opentimestamps', (opts) =>
-    new OpenTimestampsProvider(opts as unknown as OpenTimestampsProviderConfig),
-  );
-
-  registerAnchorProviderFactory('ethereum', (opts) =>
-    new EthereumProvider(opts as unknown as EthereumProviderConfig),
-  );
-
-  registerAnchorProviderFactory('solana', (opts) =>
-    new SolanaProvider(opts as unknown as SolanaProviderConfig),
-  );
-
-  registered = true;
-}

package/src/types.ts

@@ -1,27 +0,0 @@
-/**
- * @file types.ts
- * @description Shared types for anchor provider implementations.
- */
-
-/**
- * Base configuration shared by all anchor providers.
- */
-export interface BaseProviderConfig {
-  /** Request timeout in milliseconds. Default: 30000. */
-  timeoutMs?: number;
-  /** Number of retries on transient failures. Default: 3. */
-  retries?: number;
-  /** Base delay between retries in milliseconds. Default: 1000. */
-  retryDelayMs?: number;
-}
-
-/**
- * Resolve a base config with defaults.
- */
-export function resolveBaseConfig(config?: Partial<BaseProviderConfig>): Required<BaseProviderConfig> {
-  return {
-    timeoutMs: config?.timeoutMs ?? 30_000,
-    retries: config?.retries ?? 3,
-    retryDelayMs: config?.retryDelayMs ?? 1_000,
-  };
-}

package/src/utils/http-client.ts

@@ -1,75 +0,0 @@
-/**
- * @file http-client.ts
- * @description Shared HTTP fetch wrapper with retry and timeout for anchor providers.
- */
-
-export interface HttpRequestOptions {
-  /** Request timeout in milliseconds. */
-  timeoutMs?: number;
-  /** Number of retries on transient failures (5xx, network errors). */
-  retries?: number;
-  /** Base delay between retries in milliseconds (exponential backoff). */
-  retryDelayMs?: number;
-}
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_RETRIES = 3;
-const DEFAULT_RETRY_DELAY_MS = 1_000;
-
-/**
- * Fetch with exponential backoff retry on transient failures.
- *
- * @param url - The URL to fetch.
- * @param init - Standard RequestInit options.
- * @param options - Retry and timeout configuration.
- * @returns The fetch Response.
- * @throws On non-transient errors or after all retries exhausted.
- */
-export async function fetchWithRetry(
-  url: string,
-  init: RequestInit = {},
-  options?: HttpRequestOptions,
-): Promise<Response> {
-  const maxRetries = options?.retries ?? DEFAULT_RETRIES;
-  const baseDelay = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-
-  let lastError: Error | undefined;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-      const response = await fetch(url, {
-        ...init,
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeout);
-
-      // Don't retry client errors (4xx), only server errors (5xx)
-      if (response.ok || (response.status >= 400 && response.status < 500)) {
-        return response;
-      }
-
-      // Server error — retry
-      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-
-      // Don't retry aborted requests (timeout)
-      if (lastError.name === 'AbortError') {
-        lastError = new Error(`Request timed out after ${timeoutMs}ms`);
-      }
-    }
-
-    // Exponential backoff before next retry
-    if (attempt < maxRetries) {
-      const delay = baseDelay * Math.pow(2, attempt);
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  }
-
-  throw lastError ?? new Error('Request failed after all retries');
-}

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export { fetchWithRetry } from './http-client.js';
-export type { HttpRequestOptions } from './http-client.js';
-export { canonicalizeAnchor, hashCanonicalAnchor } from './serialization.js';

package/src/utils/serialization.ts

@@ -1,33 +0,0 @@
-/**
- * @file serialization.ts
- * @description Deterministic serialization for anchor records before external publishing.
- */
-
-import type { AnchorRecord } from '@framers/agentos';
-import { createHash } from 'crypto';
-
-/**
- * Serialize an AnchorRecord to a canonical JSON string with sorted keys.
- * Ensures all providers hash/publish the same byte representation.
- */
-export function canonicalizeAnchor(anchor: AnchorRecord): string {
-  const canonical = {
-    eventCount: anchor.eventCount,
-    id: anchor.id,
-    merkleRoot: anchor.merkleRoot,
-    sequenceFrom: anchor.sequenceFrom,
-    sequenceTo: anchor.sequenceTo,
-    signature: anchor.signature,
-    timestamp: anchor.timestamp,
-  };
-  return JSON.stringify(canonical);
-}
-
-/**
- * Compute a SHA-256 hex digest of the canonical anchor representation.
- * Used by providers as the hash to publish externally.
- */
-export async function hashCanonicalAnchor(anchor: AnchorRecord): Promise<string> {
-  const canonical = canonicalizeAnchor(anchor);
-  return createHash('sha256').update(canonical, 'utf8').digest('hex');
-}

package/test/integration.spec.ts

@@ -1,175 +0,0 @@
-/**
- * @file integration.spec.ts
- * @description End-to-end integration tests verifying that the extension's
- * registerExtensionProviders() correctly hooks into the core
- * createAnchorProvider() factory for all provider types.
- *
- * Uses vi.resetModules() + dynamic import to get a fresh register.ts module
- * per test (bypassing the idempotent `registered` flag).
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { AnchorRecord } from '@framers/agentos';
-
-// Use vi.hoisted() so the mock fn is available before vi.mock hoisting
-const { mockRegister, factories } = vi.hoisted(() => {
-  const factories = new Map<string, (opts: any) => any>();
-  const mockRegister = vi.fn((type: string, factory: (opts: any) => any) => {
-    factories.set(type, factory);
-  });
-  return { mockRegister, factories };
-});
-
-vi.mock('@framers/agentos', () => ({
-  registerAnchorProviderFactory: mockRegister,
-}));
-
-function createMockAnchor(): AnchorRecord {
-  return {
-    id: 'anchor-int-001',
-    merkleRoot: 'abc123',
-    sequenceFrom: 1,
-    sequenceTo: 5,
-    eventCount: 5,
-    timestamp: '2025-01-15T00:00:00.000Z',
-    signature: 'sig-base64',
-  };
-}
-
-async function freshRegister(): Promise<void> {
-  // Reset module cache so register.ts `registered` flag starts false
-  vi.resetModules();
-  // Re-mock since resetModules clears mocks too
-  vi.doMock('@framers/agentos', () => ({
-    registerAnchorProviderFactory: mockRegister,
-  }));
-  const mod = await import('../src/register.js');
-  mod.registerExtensionProviders();
-}
-
-describe('Extension ↔ Core Integration', () => {
-  beforeEach(async () => {
-    mockRegister.mockClear();
-    factories.clear();
-    await freshRegister();
-  });
-
-  it('should register all 5 provider types with the core factory', () => {
-    expect(factories.has('worm-snapshot')).toBe(true);
-    expect(factories.has('rekor')).toBe(true);
-    expect(factories.has('opentimestamps')).toBe(true);
-    expect(factories.has('ethereum')).toBe(true);
-    expect(factories.has('solana')).toBe(true);
-  });
-
-  // ---------------------------------------------------------------------------
-  // Factory-created provider identity
-  // ---------------------------------------------------------------------------
-
-  it('worm-snapshot factory should create correct provider', async () => {
-    const { WormSnapshotProvider } = await import('../src/providers/WormSnapshotProvider.js');
-    const factory = factories.get('worm-snapshot')!;
-    const provider = factory({ bucket: 'test-bucket', region: 'us-east-1' });
-    expect(provider).toBeInstanceOf(WormSnapshotProvider);
-    expect(provider.id).toBe('worm-snapshot');
-    expect(provider.proofLevel).toBe('externally-archived');
-  });
-
-  it('rekor factory should create RekorProvider with custom server', async () => {
-    const { RekorProvider } = await import('../src/providers/RekorProvider.js');
-    const factory = factories.get('rekor')!;
-    const provider = factory({ serverUrl: 'https://custom.rekor.dev' });
-    expect(provider).toBeInstanceOf(RekorProvider);
-    expect(provider.id).toBe('rekor');
-    expect(provider.proofLevel).toBe('publicly-auditable');
-  });
-
-  it('opentimestamps factory should create OpenTimestampsProvider', async () => {
-    const { OpenTimestampsProvider } = await import('../src/providers/OpenTimestampsProvider.js');
-    const factory = factories.get('opentimestamps')!;
-    const provider = factory({});
-    expect(provider).toBeInstanceOf(OpenTimestampsProvider);
-    expect(provider.id).toBe('opentimestamps');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  it('ethereum factory should create EthereumProvider with chain ID', async () => {
-    const { EthereumProvider } = await import('../src/providers/EthereumProvider.js');
-    const factory = factories.get('ethereum')!;
-    const provider = factory({ rpcUrl: 'https://eth.test', chainId: 11155111 });
-    expect(provider).toBeInstanceOf(EthereumProvider);
-    expect(provider.id).toBe('ethereum');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  it('solana factory should create SolanaProvider', async () => {
-    const { SolanaProvider } = await import('../src/providers/SolanaProvider.js');
-    const factory = factories.get('solana')!;
-    const provider = factory({ rpcUrl: 'https://solana.test', programId: '11111111111111111111111111111111' });
-    expect(provider).toBeInstanceOf(SolanaProvider);
-    expect(provider.id).toBe('solana');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  // ---------------------------------------------------------------------------
-  // Factory-created providers behavior (stubs)
-  // ---------------------------------------------------------------------------
-
-  it('all factory-created providers should return failure from stub publish()', async () => {
-    const anchor = createMockAnchor();
-
-    const configs: [string, Record<string, unknown>, RegExp][] = [
-      ['worm-snapshot', { bucket: 'b', region: 'us-east-1' }, /not yet implemented/i],
-      ['rekor', {}, /not yet implemented/i],
-      ['opentimestamps', {}, /not yet implemented/i],
-      ['ethereum', { rpcUrl: 'https://eth.test' }, /not yet implemented/i],
-      ['solana', { rpcUrl: 'https://solana.test', programId: '11111111111111111111111111111111' }, /missing signer configuration/i],
-    ];
-
-    for (const [type, opts, expectedError] of configs) {
-      const factory = factories.get(type)!;
-      const provider = factory(opts);
-      const result = await provider.publish(anchor);
-      expect(result.success).toBe(false);
-      expect(result.error).toMatch(expectedError);
-      expect(result.providerId).toBe(type);
-    }
-  });
-
-  it('all factory-created providers should return false from verify()', async () => {
-    const anchor = createMockAnchor();
-
-    const configs: [string, Record<string, unknown>][] = [
-      ['worm-snapshot', { bucket: 'b', region: 'us-east-1' }],
-      ['rekor', {}],
-      ['opentimestamps', {}],
-      ['ethereum', { rpcUrl: 'https://eth.test' }],
-      ['solana', { rpcUrl: 'https://solana.test', programId: '11111111111111111111111111111111' }],
-    ];
-
-    for (const [type, opts] of configs) {
-      const factory = factories.get(type)!;
-      const provider = factory(opts);
-      const valid = await provider.verify(anchor);
-      expect(valid).toBe(false);
-    }
-  });
-
-  // ---------------------------------------------------------------------------
-  // Default config values
-  // ---------------------------------------------------------------------------
-
-  it('rekor factory should use default server URL when not provided', async () => {
-    const { RekorProvider } = await import('../src/providers/RekorProvider.js');
-    const factory = factories.get('rekor')!;
-    const provider = factory(undefined);
-    expect(provider).toBeInstanceOf(RekorProvider);
-  });
-
-  it('worm-snapshot factory should apply default retention config', () => {
-    const factory = factories.get('worm-snapshot')!;
-    const provider = factory({ bucket: 'b', region: 'r' });
-    expect(provider.id).toBe('worm-snapshot');
-    expect(provider.name).toBe('WORM Snapshot (S3 Object Lock)');
-  });
-});

package/test/providers.spec.ts

@@ -1,163 +0,0 @@
-/**
- * @file providers.spec.ts
- * @description Tests for all anchor provider implementations.
- */
-
-import { describe, it, expect } from 'vitest';
-import { WormSnapshotProvider } from '../src/providers/WormSnapshotProvider.js';
-import { RekorProvider } from '../src/providers/RekorProvider.js';
-import { OpenTimestampsProvider } from '../src/providers/OpenTimestampsProvider.js';
-import { EthereumProvider } from '../src/providers/EthereumProvider.js';
-import { SolanaProvider } from '../src/providers/SolanaProvider.js';
-import type { AnchorRecord } from '@framers/agentos';
-
-function createMockAnchor(overrides?: Partial<AnchorRecord>): AnchorRecord {
-  return {
-    id: 'anchor-001',
-    merkleRoot: 'abc123def456',
-    sequenceFrom: 1,
-    sequenceTo: 10,
-    eventCount: 10,
-    timestamp: '2025-01-15T00:00:00.000Z',
-    signature: 'mock-signature-base64',
-    ...overrides,
-  };
-}
-
-// =============================================================================
-// WormSnapshotProvider
-// =============================================================================
-
-describe('WormSnapshotProvider', () => {
-  it('should have correct id, name, and proofLevel', () => {
-    const provider = new WormSnapshotProvider({ bucket: 'test', region: 'us-east-1' });
-    expect(provider.id).toBe('worm-snapshot');
-    expect(provider.name).toBe('WORM Snapshot (S3 Object Lock)');
-    expect(provider.proofLevel).toBe('externally-archived');
-  });
-
-  it('should return failure from stub publish()', async () => {
-    const provider = new WormSnapshotProvider({ bucket: 'test', region: 'us-east-1' });
-    const result = await provider.publish(createMockAnchor());
-    expect(result.providerId).toBe('worm-snapshot');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not yet implemented');
-  });
-
-  it('should return false from stub verify()', async () => {
-    const provider = new WormSnapshotProvider({ bucket: 'test', region: 'us-east-1' });
-    const valid = await provider.verify(createMockAnchor({ externalRef: 's3://bucket/key' }));
-    expect(valid).toBe(false);
-  });
-});
-
-// =============================================================================
-// RekorProvider
-// =============================================================================
-
-describe('RekorProvider', () => {
-  it('should have correct id, name, and proofLevel', () => {
-    const provider = new RekorProvider();
-    expect(provider.id).toBe('rekor');
-    expect(provider.name).toBe('Sigstore Rekor Transparency Log');
-    expect(provider.proofLevel).toBe('publicly-auditable');
-  });
-
-  it('should use default server URL when none provided', () => {
-    const provider = new RekorProvider();
-    expect(provider).toBeDefined();
-  });
-
-  it('should return failure from stub publish()', async () => {
-    const provider = new RekorProvider();
-    const result = await provider.publish(createMockAnchor());
-    expect(result.providerId).toBe('rekor');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not yet implemented');
-  });
-
-  it('should return false from stub verify() without externalRef', async () => {
-    const provider = new RekorProvider();
-    const valid = await provider.verify(createMockAnchor());
-    expect(valid).toBe(false);
-  });
-});
-
-// =============================================================================
-// OpenTimestampsProvider
-// =============================================================================
-
-describe('OpenTimestampsProvider', () => {
-  it('should have correct id, name, and proofLevel', () => {
-    const provider = new OpenTimestampsProvider();
-    expect(provider.id).toBe('opentimestamps');
-    expect(provider.name).toBe('OpenTimestamps (Bitcoin)');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  it('should return failure from stub publish()', async () => {
-    const provider = new OpenTimestampsProvider();
-    const result = await provider.publish(createMockAnchor());
-    expect(result.providerId).toBe('opentimestamps');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not yet implemented');
-  });
-
-  it('should accept custom calendar URLs', () => {
-    const provider = new OpenTimestampsProvider({
-      calendarUrls: ['https://custom.calendar.org'],
-    });
-    expect(provider).toBeDefined();
-  });
-});
-
-// =============================================================================
-// EthereumProvider
-// =============================================================================
-
-describe('EthereumProvider', () => {
-  it('should have correct id, name, and proofLevel', () => {
-    const provider = new EthereumProvider({ rpcUrl: 'https://eth.example.com' });
-    expect(provider.id).toBe('ethereum');
-    expect(provider.name).toBe('Ethereum On-Chain Anchor');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  it('should return failure from stub publish()', async () => {
-    const provider = new EthereumProvider({ rpcUrl: 'https://eth.example.com' });
-    const result = await provider.publish(createMockAnchor());
-    expect(result.providerId).toBe('ethereum');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not yet implemented');
-  });
-
-  it('should accept chain ID and contract address', () => {
-    const provider = new EthereumProvider({
-      rpcUrl: 'https://eth.example.com',
-      chainId: 11155111,
-      contractAddress: '0x1234567890abcdef',
-    });
-    expect(provider).toBeDefined();
-  });
-});
-
-// =============================================================================
-// SolanaProvider
-// =============================================================================
-
-describe('SolanaProvider', () => {
-  it('should have correct id, name, and proofLevel', () => {
-    const provider = new SolanaProvider({ rpcUrl: 'https://solana.test', programId: '11111111111111111111111111111111' });
-    expect(provider.id).toBe('solana');
-    expect(provider.name).toBe('Solana On-Chain Anchor (Wunderland)');
-    expect(provider.proofLevel).toBe('publicly-timestamped');
-  });
-
-  it('should return failure from publish() when signer config is missing', async () => {
-    const provider = new SolanaProvider({ rpcUrl: 'https://solana.test', programId: '11111111111111111111111111111111' });
-    const result = await provider.publish(createMockAnchor());
-    expect(result.providerId).toBe('solana');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Missing signer configuration');
-  });
-});

package/test/register.spec.ts

@@ -1,69 +0,0 @@
-/**
- * @file register.spec.ts
- * @description Tests for the extension provider registration with core AgentOS factory.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Use vi.hoisted() so the mock fn is available before vi.mock hoisting
-const mockRegister = vi.hoisted(() => vi.fn());
-vi.mock('@framers/agentos', () => ({
-  registerAnchorProviderFactory: mockRegister,
-}));
-
-// Import after mocking
-import { registerExtensionProviders } from '../src/register.js';
-
-describe('registerExtensionProviders', () => {
-  beforeEach(() => {
-    mockRegister.mockClear();
-  });
-
-  it('should register all 5 provider factories', async () => {
-    // Re-import to reset the `registered` flag
-    const mod = await import('../src/register.js');
-
-    // Force reset by accessing internals — in a fresh module this is not needed
-    // but vitest caches modules, so we call it knowing it may be idempotent
-    mod.registerExtensionProviders();
-
-    // Verify at least 4 registrations happened (first call registers all 4)
-    const types = mockRegister.mock.calls.map((call: unknown[]) => call[0]);
-    expect(types).toContain('worm-snapshot');
-    expect(types).toContain('rekor');
-    expect(types).toContain('opentimestamps');
-    expect(types).toContain('ethereum');
-    expect(types).toContain('solana');
-  });
-
-  it('should register factories that create correct provider instances', () => {
-    // Find the rekor factory call
-    const rekorCall = mockRegister.mock.calls.find((call: unknown[]) => call[0] === 'rekor');
-    if (rekorCall) {
-      const factory = rekorCall[1] as (opts: any) => any;
-      const provider = factory({ serverUrl: 'https://custom.rekor.dev' });
-      expect(provider.id).toBe('rekor');
-      expect(provider.proofLevel).toBe('publicly-auditable');
-    }
-  });
-
-  it('should register factories that create providers with options', () => {
-    const ethCall = mockRegister.mock.calls.find((call: unknown[]) => call[0] === 'ethereum');
-    if (ethCall) {
-      const factory = ethCall[1] as (opts: any) => any;
-      const provider = factory({ rpcUrl: 'https://eth.test', chainId: 5 });
-      expect(provider.id).toBe('ethereum');
-      expect(provider.proofLevel).toBe('publicly-timestamped');
-    }
-  });
-
-  it('should register WormSnapshot factory with config', () => {
-    const wormCall = mockRegister.mock.calls.find((call: unknown[]) => call[0] === 'worm-snapshot');
-    if (wormCall) {
-      const factory = wormCall[1] as (opts: any) => any;
-      const provider = factory({ bucket: 'test-bucket', region: 'us-west-2' });
-      expect(provider.id).toBe('worm-snapshot');
-      expect(provider.proofLevel).toBe('externally-archived');
-    }
-  });
-});

package/test/types.spec.ts

@@ -1,55 +0,0 @@
-/**
- * @file types.spec.ts
- * @description Tests for shared types and config resolution.
- */
-
-import { describe, it, expect } from 'vitest';
-import { resolveBaseConfig } from '../src/types.js';
-import type { BaseProviderConfig } from '../src/types.js';
-
-describe('resolveBaseConfig', () => {
-  it('should return defaults when no config provided', () => {
-    const resolved = resolveBaseConfig();
-    expect(resolved.timeoutMs).toBe(30_000);
-    expect(resolved.retries).toBe(3);
-    expect(resolved.retryDelayMs).toBe(1_000);
-  });
-
-  it('should return defaults when empty object provided', () => {
-    const resolved = resolveBaseConfig({});
-    expect(resolved.timeoutMs).toBe(30_000);
-    expect(resolved.retries).toBe(3);
-    expect(resolved.retryDelayMs).toBe(1_000);
-  });
-
-  it('should override specific fields', () => {
-    const config: Partial<BaseProviderConfig> = {
-      timeoutMs: 5000,
-      retries: 1,
-    };
-    const resolved = resolveBaseConfig(config);
-    expect(resolved.timeoutMs).toBe(5000);
-    expect(resolved.retries).toBe(1);
-    expect(resolved.retryDelayMs).toBe(1_000); // default
-  });
-
-  it('should override all fields', () => {
-    const config: BaseProviderConfig = {
-      timeoutMs: 10_000,
-      retries: 5,
-      retryDelayMs: 500,
-    };
-    const resolved = resolveBaseConfig(config);
-    expect(resolved.timeoutMs).toBe(10_000);
-    expect(resolved.retries).toBe(5);
-    expect(resolved.retryDelayMs).toBe(500);
-  });
-
-  it('should return a Required<BaseProviderConfig>', () => {
-    const resolved = resolveBaseConfig();
-    // All fields should be defined (not undefined)
-    expect(typeof resolved.timeoutMs).toBe('number');
-    expect(typeof resolved.retries).toBe('number');
-    expect(typeof resolved.retryDelayMs).toBe('number');
-  });
-});