@charming_groot/providers 0.1.0

package/tests/circuit-breaker.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CircuitBreakerProvider } from '../src/circuit-breaker.js';
+import { ProviderError } from '@charming_groot/core';
+import type { ILlmProvider, LlmResponse, Message } from '@charming_groot/core';
+
+const MOCK_RESPONSE: LlmResponse = {
+  content: 'ok',
+  toolCalls: [],
+  usage: { inputTokens: 5, outputTokens: 3 },
+  stopReason: 'end_turn',
+};
+
+const MESSAGES: Message[] = [{ role: 'user', content: 'test' }];
+
+function makeMockProvider(impl?: Partial<ILlmProvider>): ILlmProvider {
+  return {
+    providerId: 'mock',
+    chat: vi.fn().mockResolvedValue(MOCK_RESPONSE),
+    stream: vi.fn().mockImplementation(async function* () { yield* []; }),
+    ...impl,
+  };
+}
+
+describe('CircuitBreakerProvider — 상태 전이', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('초기 상태는 CLOSED다', () => {
+    const cb = new CircuitBreakerProvider(makeMockProvider());
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('성공 시 CLOSED 상태를 유지한다', async () => {
+    const cb = new CircuitBreakerProvider(makeMockProvider());
+    await cb.chat(MESSAGES);
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('failureThreshold 연속 실패 시 OPEN으로 전이한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn().mockRejectedValue(new ProviderError('server error 500')),
+    });
+    const cb = new CircuitBreakerProvider(inner, { failureThreshold: 3 });
+
+    for (let i = 0; i < 3; i++) {
+      await cb.chat(MESSAGES).catch(() => {});
+    }
+
+    expect(cb.currentState).toBe('OPEN');
+  });
+
+  it('OPEN 상태에서 즉시 ProviderError를 던진다 (실제 provider 호출 없음)', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn().mockRejectedValue(new ProviderError('error')),
+    });
+    const cb = new CircuitBreakerProvider(inner, {
+      failureThreshold: 2,
+      openTimeoutMs: 10_000,
+    });
+
+    // OPEN으로 만들기
+    for (let i = 0; i < 2; i++) {
+      await cb.chat(MESSAGES).catch(() => {});
+    }
+    expect(cb.currentState).toBe('OPEN');
+
+    const callsBefore = (inner.chat as ReturnType<typeof vi.fn>).mock.calls.length;
+    await expect(cb.chat(MESSAGES)).rejects.toThrow('Circuit breaker OPEN');
+    // inner provider는 호출되지 않아야 함
+    expect((inner.chat as ReturnType<typeof vi.fn>).mock.calls.length).toBe(callsBefore);
+  });
+
+  it('openTimeoutMs 경과 후 HALF_OPEN으로 전이한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('error'))
+        .mockRejectedValueOnce(new ProviderError('error'))
+        .mockResolvedValue(MOCK_RESPONSE), // probe 성공
+    });
+    const cb = new CircuitBreakerProvider(inner, {
+      failureThreshold: 2,
+      openTimeoutMs: 5_000,
+      successThreshold: 1,
+    });
+
+    for (let i = 0; i < 2; i++) {
+      await cb.chat(MESSAGES).catch(() => {});
+    }
+    expect(cb.currentState).toBe('OPEN');
+
+    vi.advanceTimersByTime(5_001);
+
+    // probe 요청 — 성공 → CLOSED
+    await cb.chat(MESSAGES);
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('HALF_OPEN에서 probe 실패 시 OPEN으로 돌아간다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn().mockRejectedValue(new ProviderError('error')),
+    });
+    const cb = new CircuitBreakerProvider(inner, {
+      failureThreshold: 2,
+      openTimeoutMs: 1_000,
+    });
+
+    for (let i = 0; i < 2; i++) {
+      await cb.chat(MESSAGES).catch(() => {});
+    }
+
+    vi.advanceTimersByTime(1_001);
+    // HALF_OPEN probe → 실패 → OPEN
+    await cb.chat(MESSAGES).catch(() => {});
+    expect(cb.currentState).toBe('OPEN');
+  });
+
+  it('HALF_OPEN에서 successThreshold 성공 시 CLOSED로 전이한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('err'))
+        .mockRejectedValueOnce(new ProviderError('err'))
+        .mockResolvedValue(MOCK_RESPONSE),
+    });
+    const cb = new CircuitBreakerProvider(inner, {
+      failureThreshold: 2,
+      openTimeoutMs: 1_000,
+      successThreshold: 2,
+    });
+
+    for (let i = 0; i < 2; i++) {
+      await cb.chat(MESSAGES).catch(() => {});
+    }
+    expect(cb.currentState).toBe('OPEN');
+
+    vi.advanceTimersByTime(1_001);
+
+    // 첫 번째 성공 → HALF_OPEN 유지
+    await cb.chat(MESSAGES);
+    expect(cb.currentState).toBe('HALF_OPEN');
+
+    // 두 번째 성공 → CLOSED
+    await cb.chat(MESSAGES);
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('CLOSED에서 성공하면 failureCount를 리셋한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('err'))  // call 1: fail
+        .mockRejectedValueOnce(new ProviderError('err'))  // call 2: fail
+        .mockResolvedValueOnce(MOCK_RESPONSE)              // call 3: success → reset
+        .mockRejectedValueOnce(new ProviderError('err'))  // call 4: fail
+        .mockRejectedValueOnce(new ProviderError('err'))  // call 5: fail
+        .mockResolvedValue(MOCK_RESPONSE),                 // default
+    });
+    const cb = new CircuitBreakerProvider(inner, { failureThreshold: 3 });
+
+    // 2번 실패
+    await cb.chat(MESSAGES).catch(() => {});
+    await cb.chat(MESSAGES).catch(() => {});
+    expect(cb.currentState).toBe('CLOSED');
+
+    // 성공 → failure count reset
+    await cb.chat(MESSAGES);
+    expect(cb.currentState).toBe('CLOSED');
+
+    // 다시 2번 실패해도 OPEN이 되지 않음 (threshold 3 기준)
+    await cb.chat(MESSAGES).catch(() => {});
+    await cb.chat(MESSAGES).catch(() => {});
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('providerId를 inner provider로부터 위임한다', () => {
+    const cb = new CircuitBreakerProvider(makeMockProvider());
+    expect(cb.providerId).toBe('mock');
+  });
+});
+
+describe('CircuitBreakerProvider — stream', () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it('CLOSED 상태에서 stream이 정상 동작한다', async () => {
+    const inner = makeMockProvider({
+      stream: vi.fn().mockImplementation(async function* () {
+        yield { type: 'text_delta' as const, text: 'hello' };
+        yield { type: 'done' as const, response: MOCK_RESPONSE };
+      }),
+    });
+    const cb = new CircuitBreakerProvider(inner);
+
+    const events = [];
+    for await (const e of cb.stream(MESSAGES)) {
+      events.push(e);
+    }
+    expect(events).toHaveLength(2);
+    expect(cb.currentState).toBe('CLOSED');
+  });
+
+  it('stream 실패가 failureCount에 반영된다', async () => {
+    const inner = makeMockProvider({
+      stream: vi.fn().mockImplementation(async function* () {
+        throw new ProviderError('stream error');
+      }),
+    });
+    const cb = new CircuitBreakerProvider(inner, { failureThreshold: 2 });
+
+    for (let i = 0; i < 2; i++) {
+      try {
+        for await (const _ of cb.stream(MESSAGES)) { /* empty */ }
+      } catch { /* expected */ }
+    }
+    expect(cb.currentState).toBe('OPEN');
+  });
+});

package/tests/claude-provider.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { ProviderConfig } from '@charming_groot/core';
+import { ClaudeProvider } from '../src/claude-provider.js';
+
+const CONFIG: ProviderConfig = {
+  providerId: 'claude',
+  model: 'claude-opus-4-6',
+  auth: { type: 'api-key' as const, apiKey: 'test-key' },
+  maxTokens: 4096,
+  temperature: 0.7,
+};
+
+describe('ClaudeProvider', () => {
+  it('should have correct providerId', () => {
+    const provider = new ClaudeProvider(CONFIG);
+    expect(provider.providerId).toBe('claude');
+  });
+
+  it('should implement chat method', () => {
+    const provider = new ClaudeProvider(CONFIG);
+    expect(typeof provider.chat).toBe('function');
+  });
+
+  it('should implement stream method', () => {
+    const provider = new ClaudeProvider(CONFIG);
+    expect(typeof provider.stream).toBe('function');
+  });
+
+  it('should throw ProviderError on chat failure', async () => {
+    const provider = new ClaudeProvider({ ...CONFIG, auth: { type: 'api-key' as const, apiKey: 'invalid' } });
+    await expect(
+      provider.chat([{ role: 'user', content: 'test' }])
+    ).rejects.toThrow();
+  });
+});

package/tests/openai-provider.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import type { ProviderConfig } from '@charming_groot/core';
+import { OpenAIProvider } from '../src/openai-provider.js';
+
+const CONFIG: ProviderConfig = {
+  providerId: 'openai',
+  model: 'gpt-4',
+  auth: { type: 'api-key' as const, apiKey: 'test-key' },
+  maxTokens: 4096,
+  temperature: 0.7,
+};
+
+describe('OpenAIProvider', () => {
+  it('should have correct providerId', () => {
+    const provider = new OpenAIProvider(CONFIG);
+    expect(provider.providerId).toBe('openai');
+  });
+
+  it('should implement chat method', () => {
+    const provider = new OpenAIProvider(CONFIG);
+    expect(typeof provider.chat).toBe('function');
+  });
+
+  it('should implement stream method', () => {
+    const provider = new OpenAIProvider(CONFIG);
+    expect(typeof provider.stream).toBe('function');
+  });
+
+  it('should throw ProviderError on chat failure', async () => {
+    const provider = new OpenAIProvider({ ...CONFIG, auth: { type: 'api-key' as const, apiKey: 'invalid' } });
+    await expect(
+      provider.chat([{ role: 'user', content: 'test' }])
+    ).rejects.toThrow();
+  });
+});

package/tests/provider-factory.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import type { ProviderConfig, ILlmProvider, Message, LlmResponse, StreamEvent, ToolDescription } from '@charming_groot/core';
+import { ProviderError } from '@charming_groot/core';
+import { createProvider, registerProvider, getProviderRegistry } from '../src/provider-factory.js';
+import { CircuitBreakerProvider } from '../src/circuit-breaker.js';
+
+const CLAUDE_CONFIG: ProviderConfig = {
+  providerId: 'claude',
+  model: 'claude-opus-4-6',
+  auth: { type: 'api-key' as const, apiKey: 'test-key' },
+  maxTokens: 4096,
+  temperature: 0.7,
+};
+
+const OPENAI_CONFIG: ProviderConfig = {
+  providerId: 'openai',
+  model: 'gpt-4',
+  auth: { type: 'api-key' as const, apiKey: 'test-key' },
+  maxTokens: 4096,
+  temperature: 0.7,
+};
+
+describe('ProviderFactory', () => {
+  it('should create a Claude provider', () => {
+    const provider = createProvider(CLAUDE_CONFIG);
+    expect(provider).toBeInstanceOf(CircuitBreakerProvider);
+    expect(provider.providerId).toBe('claude');
+  });
+
+  it('should create an OpenAI provider', () => {
+    const provider = createProvider(OPENAI_CONFIG);
+    expect(provider).toBeInstanceOf(CircuitBreakerProvider);
+    expect(provider.providerId).toBe('openai');
+  });
+
+  it('should throw for unknown provider', () => {
+    expect(() =>
+      createProvider({ ...CLAUDE_CONFIG, providerId: 'unknown' })
+    ).toThrow(ProviderError);
+  });
+
+  it('should include available providers in error message', () => {
+    try {
+      createProvider({ ...CLAUDE_CONFIG, providerId: 'unknown' });
+    } catch (e) {
+      expect((e as ProviderError).message).toContain('claude');
+      expect((e as ProviderError).message).toContain('openai');
+    }
+  });
+
+  it('should allow registering custom providers', () => {
+    class CustomProvider implements ILlmProvider {
+      readonly providerId = 'custom';
+      async chat(_messages: readonly Message[], _tools?: readonly ToolDescription[]): Promise<LlmResponse> {
+        return { content: '', stopReason: 'end_turn', toolCalls: [], usage: { inputTokens: 0, outputTokens: 0 } };
+      }
+      async *stream(_messages: readonly Message[], _tools?: readonly ToolDescription[]): AsyncIterable<StreamEvent> {
+        yield { type: 'done', response: { content: '', stopReason: 'end_turn', toolCalls: [], usage: { inputTokens: 0, outputTokens: 0 } } };
+      }
+    }
+    registerProvider('test-custom', CustomProvider);
+    const provider = createProvider({ ...CLAUDE_CONFIG, providerId: 'test-custom' });
+    expect(provider.providerId).toBe('custom');
+    // cleanup
+    getProviderRegistry().unregister('test-custom');
+  });
+
+  it('should expose the provider registry', () => {
+    const registry = getProviderRegistry();
+    expect(registry.has('claude')).toBe(true);
+    expect(registry.has('openai')).toBe(true);
+  });
+});

package/tests/retry-provider-new.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RetryProvider } from '../src/retry-provider.js';
+import { ProviderError } from '@charming_groot/core';
+import type { ILlmProvider, LlmResponse, Message } from '@charming_groot/core';
+
+const MOCK_RESPONSE: LlmResponse = {
+  content: 'test response',
+  toolCalls: [],
+  usage: { inputTokens: 10, outputTokens: 5 },
+  stopReason: 'end_turn',
+};
+
+function makeMockProvider(impl?: Partial<ILlmProvider>): ILlmProvider {
+  return {
+    providerId: 'mock',
+    chat: vi.fn().mockResolvedValue(MOCK_RESPONSE),
+    stream: vi.fn().mockImplementation(async function* () { yield* []; }),
+    ...impl,
+  };
+}
+
+const MESSAGES: Message[] = [{ role: 'user', content: 'hello' }];
+
+describe('RetryProvider — chat', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  it('첫 번째 시도에 성공하면 바로 반환한다', async () => {
+    const inner = makeMockProvider();
+    const provider = new RetryProvider(inner, { maxRetries: 3 });
+
+    const result = await provider.chat(MESSAGES);
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('rate limit(429) 에러 시 재시도한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('429 rate limit exceeded'))
+        .mockResolvedValue(MOCK_RESPONSE),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 3, baseDelayMs: 0 });
+
+    const promise = provider.chat(MESSAGES);
+    await vi.runAllTimersAsync();
+    const result = await promise;
+
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(2);
+  });
+
+  it('서버 에러(500) 시 재시도한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('500 internal server error'))
+        .mockResolvedValue(MOCK_RESPONSE),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 3, baseDelayMs: 0 });
+
+    const promise = provider.chat(MESSAGES);
+    await vi.runAllTimersAsync();
+    const result = await promise;
+
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(2);
+  });
+
+  it('네트워크 에러(econnreset) 시 재시도한다', async () => {
+    const inner = makeMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new Error('ECONNRESET connection reset'))
+        .mockResolvedValue(MOCK_RESPONSE),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 3, baseDelayMs: 0 });
+
+    const promise = provider.chat(MESSAGES);
+    await vi.runAllTimersAsync();
+    const result = await promise;
+
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(2);
+  });
+
+  it('재시도 불가 에러(400)는 즉시 던진다', async () => {
+    const error = new ProviderError('400 bad request invalid input');
+    const inner = makeMockProvider({
+      chat: vi.fn().mockRejectedValue(error),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 3, baseDelayMs: 0 });
+
+    await expect(provider.chat(MESSAGES)).rejects.toThrow('400 bad request');
+    expect(inner.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('maxRetries 소진 후 마지막 에러를 던진다', async () => {
+    const error = new ProviderError('overloaded');
+    const inner = makeMockProvider({
+      chat: vi.fn().mockRejectedValue(error),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 2, baseDelayMs: 0 });
+
+    const promise = provider.chat(MESSAGES);
+    await vi.runAllTimersAsync();
+
+    await expect(promise).rejects.toThrow('overloaded');
+    expect(inner.chat).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
+  });
+
+  it('providerId를 inner provider로부터 위임한다', () => {
+    const inner = makeMockProvider();
+    const provider = new RetryProvider(inner);
+    expect(provider.providerId).toBe('mock');
+  });
+});
+
+describe('RetryProvider — stream', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  it('stream이 성공하면 이벤트를 그대로 반환한다', async () => {
+    const inner = makeMockProvider({
+      stream: vi.fn().mockImplementation(async function* () {
+        yield { type: 'text_delta' as const, text: 'hello' };
+        yield { type: 'done' as const, response: MOCK_RESPONSE };
+      }),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 2, baseDelayMs: 0 });
+
+    const events = [];
+    for await (const event of provider.stream(MESSAGES)) {
+      events.push(event);
+    }
+
+    expect(events).toHaveLength(2);
+    expect(events[0]).toEqual({ type: 'text_delta', text: 'hello' });
+  });
+
+  it('stream에서 재시도 가능 에러 발생 시 재시도한다', async () => {
+    let callCount = 0;
+    const inner = makeMockProvider({
+      stream: vi.fn().mockImplementation(async function* () {
+        callCount++;
+        if (callCount === 1) throw new ProviderError('503 service unavailable');
+        yield { type: 'done' as const, response: MOCK_RESPONSE };
+      }),
+    });
+    const provider = new RetryProvider(inner, { maxRetries: 2, baseDelayMs: 0 });
+
+    const promise = (async () => {
+      const events = [];
+      for await (const event of provider.stream(MESSAGES)) {
+        events.push(event);
+      }
+      return events;
+    })();
+
+    await vi.runAllTimersAsync();
+    const events = await promise;
+
+    expect(callCount).toBe(2);
+    expect(events).toHaveLength(1);
+  });
+});

package/tests/retry-provider.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi } from 'vitest';
+import { RetryProvider } from '../src/retry-provider.js';
+import type { ILlmProvider, LlmResponse, StreamEvent } from '@charming_groot/core';
+import { ProviderError } from '@charming_groot/core';
+
+const MOCK_RESPONSE: LlmResponse = {
+  content: 'Hello',
+  stopReason: 'end_turn',
+  toolCalls: [],
+  usage: { inputTokens: 10, outputTokens: 5 },
+};
+
+function createMockProvider(overrides?: Partial<ILlmProvider>): ILlmProvider {
+  return {
+    providerId: 'mock',
+    chat: vi.fn().mockResolvedValue(MOCK_RESPONSE),
+    async *stream() {
+      yield { type: 'done', response: MOCK_RESPONSE } as StreamEvent;
+    },
+    ...overrides,
+  };
+}
+
+describe('RetryProvider', () => {
+  it('should pass through successful calls', async () => {
+    const inner = createMockProvider();
+    const retry = new RetryProvider(inner);
+
+    const result = await retry.chat([], []);
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry on rate limit errors', async () => {
+    const inner = createMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('rate limit exceeded (429)'))
+        .mockResolvedValueOnce(MOCK_RESPONSE),
+    });
+    const retry = new RetryProvider(inner, { baseDelayMs: 10 });
+
+    const result = await retry.chat([], []);
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(2);
+  });
+
+  it('should retry on transient network errors', async () => {
+    const inner = createMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('ECONNRESET'))
+        .mockResolvedValueOnce(MOCK_RESPONSE),
+    });
+    const retry = new RetryProvider(inner, { baseDelayMs: 10 });
+
+    const result = await retry.chat([], []);
+    expect(result).toBe(MOCK_RESPONSE);
+    expect(inner.chat).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not retry on non-retryable errors', async () => {
+    const inner = createMockProvider({
+      chat: vi.fn().mockRejectedValue(new ProviderError('Invalid API key')),
+    });
+    const retry = new RetryProvider(inner, { baseDelayMs: 10 });
+
+    await expect(retry.chat([], [])).rejects.toThrow('Invalid API key');
+    expect(inner.chat).toHaveBeenCalledTimes(1);
+  });
+
+  it('should give up after maxRetries', async () => {
+    const inner = createMockProvider({
+      chat: vi.fn().mockRejectedValue(new ProviderError('rate limit exceeded (429)')),
+    });
+    const retry = new RetryProvider(inner, { maxRetries: 2, baseDelayMs: 10 });
+
+    await expect(retry.chat([], [])).rejects.toThrow('rate limit');
+    expect(inner.chat).toHaveBeenCalledTimes(3); // initial + 2 retries
+  });
+
+  it('should preserve providerId', () => {
+    const inner = createMockProvider();
+    const retry = new RetryProvider(inner);
+    expect(retry.providerId).toBe('mock');
+  });
+
+  it('should retry on overloaded errors', async () => {
+    const inner = createMockProvider({
+      chat: vi.fn()
+        .mockRejectedValueOnce(new ProviderError('overloaded (529)'))
+        .mockResolvedValueOnce(MOCK_RESPONSE),
+    });
+    const retry = new RetryProvider(inner, { baseDelayMs: 10 });
+
+    const result = await retry.chat([], []);
+    expect(result).toBe(MOCK_RESPONSE);
+  });
+
+  it('should retry stream on transient errors', async () => {
+    let attempt = 0;
+    const inner = createMockProvider({
+      async *stream() {
+        attempt++;
+        if (attempt === 1) {
+          throw new ProviderError('socket hang up');
+        }
+        yield { type: 'done', response: MOCK_RESPONSE } as StreamEvent;
+      },
+    });
+    const retry = new RetryProvider(inner, { baseDelayMs: 10 });
+
+    const events: StreamEvent[] = [];
+    for await (const event of retry.stream([], [])) {
+      events.push(event);
+    }
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe('done');
+  });
+});