chore: import upstream snapshot with attribution

test/providers/hyperbolic/chat.test.ts

@@ -0,0 +1,206 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  calculateHyperbolicCost,
+  createHyperbolicProvider,
+  HYPERBOLIC_CHAT_MODELS,
+  HYPERBOLIC_REASONING_MODELS,
+  HyperbolicProvider,
+} from '../../../src/providers/hyperbolic/chat';
+import { OpenAiChatCompletionProvider } from '../../../src/providers/openai/chat';
+
+describe('HyperbolicProvider', () => {
+  let provider: HyperbolicProvider;
+  const modelName = 'deepseek-ai/DeepSeek-R1';
+  const options = {
+    config: {
+      config: {
+        apiKey: 'test-key',
+      },
+    },
+  };
+
+  beforeEach(() => {
+    provider = new HyperbolicProvider(modelName, options);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should create provider with correct config', () => {
+    expect(provider.id()).toBe(`hyperbolic:${modelName}`);
+    expect(provider.toString()).toBe(`[Hyperbolic Provider ${modelName}]`);
+  });
+
+  it('should convert to JSON correctly', () => {
+    const json = provider.toJSON();
+    expect(json).toEqual({
+      provider: 'hyperbolic',
+      model: modelName,
+      config: {
+        apiKeyEnvar: 'HYPERBOLIC_API_KEY',
+        apiBaseUrl: 'https://api.hyperbolic.xyz/v1',
+        config: expect.any(Object),
+      },
+    });
+  });
+
+  it('should process API response correctly for reasoning model', async () => {
+    const mockResponse = {
+      raw: {
+        usage: {
+          completion_tokens_details: {
+            reasoning_tokens: 100,
+            accepted_prediction_tokens: 50,
+            rejected_prediction_tokens: 25,
+          },
+        },
+      },
+      tokenUsage: {
+        prompt: 200,
+        completion: 150,
+      },
+    };
+
+    vi.spyOn(OpenAiChatCompletionProvider.prototype, 'callApi').mockResolvedValue(mockResponse);
+
+    const result = await provider.callApi('test prompt');
+
+    expect(result.tokenUsage.completionDetails).toEqual({
+      reasoning: 100,
+      acceptedPrediction: 50,
+      rejectedPrediction: 25,
+    });
+  });
+
+  it('should handle raw response as string', async () => {
+    const mockResponse = {
+      raw: JSON.stringify({
+        usage: {
+          completion_tokens_details: {
+            reasoning_tokens: 100,
+            accepted_prediction_tokens: 50,
+            rejected_prediction_tokens: 25,
+          },
+        },
+      }),
+      tokenUsage: {
+        prompt: 200,
+        completion: 150,
+      },
+    };
+
+    vi.spyOn(OpenAiChatCompletionProvider.prototype, 'callApi').mockResolvedValue(mockResponse);
+
+    const result = await provider.callApi('test prompt');
+
+    expect(result.tokenUsage.completionDetails).toEqual({
+      reasoning: 100,
+      acceptedPrediction: 50,
+      rejectedPrediction: 25,
+    });
+  });
+
+  it('should handle error response', async () => {
+    const mockResponse = { error: 'API error' };
+    vi.spyOn(OpenAiChatCompletionProvider.prototype, 'callApi').mockResolvedValue(mockResponse);
+
+    const result = await provider.callApi('test prompt');
+    expect(result.error).toBe('API error');
+  });
+
+  it('should handle invalid JSON in raw response', async () => {
+    const mockResponse = {
+      raw: 'invalid json',
+      tokenUsage: {
+        prompt: 200,
+        completion: 150,
+      },
+    };
+
+    vi.spyOn(OpenAiChatCompletionProvider.prototype, 'callApi').mockResolvedValue(mockResponse);
+
+    const result = await provider.callApi('test prompt');
+    expect(result.tokenUsage.completionDetails).toBeUndefined();
+  });
+
+  it('should calculate cost for non-cached response', async () => {
+    const mockResponse = {
+      raw: 'test response',
+      tokenUsage: {
+        prompt: 1000,
+        completion: 500,
+      },
+      cached: false,
+    };
+
+    vi.spyOn(OpenAiChatCompletionProvider.prototype, 'callApi').mockResolvedValue(mockResponse);
+
+    const result = await provider.callApi('test prompt');
+    expect(result.cost).toBe((0.5 / 1e6) * 1000 + (2.18 / 1e6) * 500);
+  });
+});
+
+describe('calculateHyperbolicCost', () => {
+  it('should calculate cost correctly for known model', () => {
+    const cost = calculateHyperbolicCost('deepseek-ai/DeepSeek-R1', {}, 1000, 500);
+    expect(cost).toBe((0.5 / 1e6) * 1000 + (2.18 / 1e6) * 500);
+  });
+
+  it('should calculate cost correctly for model alias', () => {
+    const cost = calculateHyperbolicCost('DeepSeek-R1', {}, 1000, 500);
+    expect(cost).toBe((0.5 / 1e6) * 1000 + (2.18 / 1e6) * 500);
+  });
+
+  it('should return undefined for unknown model', () => {
+    const cost = calculateHyperbolicCost('unknown-model', {}, 1000, 500);
+    expect(cost).toBeUndefined();
+  });
+
+  it('should return undefined if tokens are missing', () => {
+    const cost = calculateHyperbolicCost('deepseek-ai/DeepSeek-R1', {}, undefined, 500);
+    expect(cost).toBeUndefined();
+  });
+
+  it('should use custom cost from config if provided', () => {
+    const config = {
+      cost: 0.001,
+    };
+    const cost = calculateHyperbolicCost('deepseek-ai/DeepSeek-R1', config, 1000, 500);
+    expect(cost).toBe(0.001 * 1000 + 0.001 * 500);
+  });
+});
+
+describe('createHyperbolicProvider', () => {
+  it('should create provider with correct model name', () => {
+    const provider = createHyperbolicProvider('hyperbolic:deepseek-ai/DeepSeek-R1');
+    expect(provider.id()).toBe('hyperbolic:deepseek-ai/DeepSeek-R1');
+  });
+
+  it('should throw error if model name is missing', () => {
+    expect(() => createHyperbolicProvider('hyperbolic:')).toThrow('Model name is required');
+  });
+});
+
+describe('HYPERBOLIC_CHAT_MODELS', () => {
+  it('should contain valid model definitions', () => {
+    for (const model of HYPERBOLIC_CHAT_MODELS) {
+      expect(model).toHaveProperty('id');
+      expect(model).toHaveProperty('cost.input');
+      expect(model).toHaveProperty('cost.output');
+      expect(model).toHaveProperty('aliases');
+      expect(Array.isArray(model.aliases)).toBe(true);
+    }
+  });
+});
+
+describe('HYPERBOLIC_REASONING_MODELS', () => {
+  it('should be a subset of HYPERBOLIC_CHAT_MODELS', () => {
+    for (const modelId of HYPERBOLIC_REASONING_MODELS) {
+      const found = HYPERBOLIC_CHAT_MODELS.some(
+        (m) => m.id === modelId || m.aliases.includes(modelId),
+      );
+      expect(found).toBe(true);
+    }
+  });
+});