@od-oneapp/ai-platform 0.1.0

package/src/streaming/control/__tests__/streaming-control.test.ts

@@ -0,0 +1,708 @@
+/**
+ * @fileoverview Tests for streaming-control module.
+ * @module @od-oneapp/ai-platform/streaming-control
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  calculateCost,
+  createBudgetChecker,
+  createBudgetGuardedOnFinish,
+  createDevStreamController,
+  createProdStreamController,
+  createSmoothStreamTransform,
+  createStepCounter,
+  createStepLimitCondition,
+  createStreamController,
+  DEFAULT_COST_TABLE,
+  estimateCost,
+  mergeStreamConfigs,
+  smoothTextGenerator,
+  splitIntoChunks,
+  StepLimitExceededError,
+  withSmoothStream,
+  withStepLimit,
+  type TokenUsage,
+} from "..";
+
+describe('streaming-control', () => {
+  describe('calculateCost', () => {
+    it('calculates cost correctly for gpt-4o', () => {
+      const usage: TokenUsage = {
+        promptTokens: 1000,
+        completionTokens: 500,
+        totalTokens: 1500,
+      };
+
+      const cost = calculateCost(usage, 'gpt-4o');
+
+      // (1000/1000 * 0.0025) + (500/1000 * 0.01) = 0.0025 + 0.005 = 0.0075
+      expect(cost).toBeCloseTo(0.0075, 6);
+    });
+
+    it('calculates cost correctly for gpt-4o-mini', () => {
+      const usage: TokenUsage = {
+        promptTokens: 10000,
+        completionTokens: 5000,
+        totalTokens: 15000,
+      };
+
+      const cost = calculateCost(usage, 'gpt-4o-mini');
+
+      // (10000/1000 * 0.00015) + (5000/1000 * 0.0006) = 0.0015 + 0.003 = 0.0045
+      expect(cost).toBeCloseTo(0.0045, 6);
+    });
+
+    it('calculates cost correctly for claude-3-5-sonnet', () => {
+      const usage: TokenUsage = {
+        promptTokens: 2000,
+        completionTokens: 1000,
+        totalTokens: 3000,
+      };
+
+      const cost = calculateCost(usage, 'claude-3-5-sonnet');
+
+      // (2000/1000 * 0.003) + (1000/1000 * 0.015) = 0.006 + 0.015 = 0.021
+      expect(cost).toBeCloseTo(0.021, 6);
+    });
+
+    it('calculates cost correctly for claude-3-5-haiku', () => {
+      const usage: TokenUsage = {
+        promptTokens: 5000,
+        completionTokens: 2000,
+        totalTokens: 7000,
+      };
+
+      const cost = calculateCost(usage, 'claude-3-5-haiku');
+
+      // (5000/1000 * 0.0008) + (2000/1000 * 0.004) = 0.004 + 0.008 = 0.012
+      expect(cost).toBeCloseTo(0.012, 6);
+    });
+
+    it('returns 0 for unknown model', () => {
+      const usage: TokenUsage = {
+        promptTokens: 1000,
+        completionTokens: 500,
+        totalTokens: 1500,
+      };
+
+      const cost = calculateCost(usage, 'unknown-model-xyz');
+
+      expect(cost).toBe(0);
+    });
+
+    it('uses custom cost table entries', () => {
+      const usage: TokenUsage = {
+        promptTokens: 1000,
+        completionTokens: 1000,
+        totalTokens: 2000,
+      };
+
+      const cost = calculateCost(usage, 'custom-model', {
+        'custom-model': { input: 0.01, output: 0.02 },
+      });
+
+      // (1000/1000 * 0.01) + (1000/1000 * 0.02) = 0.01 + 0.02 = 0.03
+      expect(cost).toBeCloseTo(0.03, 6);
+    });
+
+    it('merges custom cost table with defaults', () => {
+      const usage: TokenUsage = {
+        promptTokens: 1000,
+        completionTokens: 500,
+        totalTokens: 1500,
+      };
+
+      // Should still work with default models when custom table is provided
+      const cost = calculateCost(usage, 'gpt-4o', {
+        'custom-model': { input: 0.01, output: 0.02 },
+      });
+
+      expect(cost).toBeCloseTo(0.0075, 6);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('estimates cost for given token counts', () => {
+      const cost = estimateCost(1000, 500, 'gpt-4o');
+      expect(cost).toBeCloseTo(0.0075, 6);
+    });
+
+    it('returns 0 for unknown model', () => {
+      const cost = estimateCost(1000, 500, 'unknown-model');
+      expect(cost).toBe(0);
+    });
+  });
+
+  describe('dEFAULT_COST_TABLE', () => {
+    it('contains entries for common OpenAI models', () => {
+      expect(DEFAULT_COST_TABLE['gpt-4o']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['gpt-4o-mini']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['gpt-4-turbo']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['gpt-3.5-turbo']).toBeDefined();
+    });
+
+    it('contains entries for common Anthropic models', () => {
+      expect(DEFAULT_COST_TABLE['claude-3-5-sonnet']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['claude-3-5-haiku']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['claude-3-opus']).toBeDefined();
+    });
+
+    it('contains entries for Google models', () => {
+      expect(DEFAULT_COST_TABLE['gemini-1.5-pro']).toBeDefined();
+      expect(DEFAULT_COST_TABLE['gemini-1.5-flash']).toBeDefined();
+    });
+  });
+
+  describe('createBudgetChecker', () => {
+    it('returns not exceeded when under token budget', () => {
+      const checkBudget = createBudgetChecker({ maxTokens: 10000 });
+      const usage: TokenUsage = { promptTokens: 5000, completionTokens: 3000, totalTokens: 8000 };
+
+      const result = checkBudget(usage, 'gpt-4o');
+
+      expect(result.exceeded).toBe(false);
+      expect(result.limit).toBeUndefined();
+    });
+
+    it('returns exceeded when over token budget', () => {
+      const onBudgetExceeded = vi.fn();
+      const checkBudget = createBudgetChecker({
+        maxTokens: 10000,
+        onBudgetExceeded,
+      });
+      const usage: TokenUsage = { promptTokens: 6000, completionTokens: 5000, totalTokens: 11000 };
+
+      const result = checkBudget(usage, 'gpt-4o');
+
+      expect(result.exceeded).toBe(true);
+      expect(result.limit).toStrictEqual({ type: 'tokens', limit: 10000, actual: 11000 });
+      expect(onBudgetExceeded).toHaveBeenCalledWith(usage, {
+        type: 'tokens',
+        limit: 10000,
+        actual: 11000,
+      });
+    });
+
+    it('returns exceeded when over cost budget', () => {
+      const onBudgetExceeded = vi.fn();
+      const checkBudget = createBudgetChecker({
+        maxCost: 0.005,
+        onBudgetExceeded,
+      });
+      // gpt-4o: (1000/1000 * 0.0025) + (500/1000 * 0.01) = 0.0075
+      const usage: TokenUsage = { promptTokens: 1000, completionTokens: 500, totalTokens: 1500 };
+
+      const result = checkBudget(usage, 'gpt-4o');
+
+      expect(result.exceeded).toBe(true);
+      expect(result.limit?.type).toBe('cost');
+      expect(result.limit?.limit).toBe(0.005);
+      expect(result.limit?.actual).toBeCloseTo(0.0075, 6);
+    });
+
+    it('checks token limit before cost limit', () => {
+      const onBudgetExceeded = vi.fn();
+      const checkBudget = createBudgetChecker({
+        maxTokens: 1000,
+        maxCost: 0.001,
+        onBudgetExceeded,
+      });
+      const usage: TokenUsage = { promptTokens: 800, completionTokens: 400, totalTokens: 1200 };
+
+      const result = checkBudget(usage, 'gpt-4o');
+
+      expect(result.exceeded).toBe(true);
+      expect(result.limit?.type).toBe('tokens');
+    });
+
+    it('does not call onBudgetExceeded when under budget', () => {
+      const onBudgetExceeded = vi.fn();
+      const checkBudget = createBudgetChecker({
+        maxTokens: 10000,
+        maxCost: 1.0,
+        onBudgetExceeded,
+      });
+      const usage: TokenUsage = { promptTokens: 1000, completionTokens: 500, totalTokens: 1500 };
+
+      checkBudget(usage, 'gpt-4o');
+
+      expect(onBudgetExceeded).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('createBudgetGuardedOnFinish', () => {
+    it('calls onBudgetExceeded when budget is exceeded', () => {
+      const onBudgetExceeded = vi.fn();
+      const onFinish = createBudgetGuardedOnFinish({ maxTokens: 1000, onBudgetExceeded }, 'gpt-4o');
+
+      onFinish({
+        usage: { promptTokens: 800, completionTokens: 500, totalTokens: 1300 },
+      });
+
+      expect(onBudgetExceeded).toHaveBeenCalledWith();
+    });
+
+    it('does nothing when usage is undefined', () => {
+      const onBudgetExceeded = vi.fn();
+      const onFinish = createBudgetGuardedOnFinish({ maxTokens: 1000, onBudgetExceeded }, 'gpt-4o');
+
+      onFinish({});
+
+      expect(onBudgetExceeded).not.toHaveBeenCalled();
+    });
+
+    it('calculates totalTokens when not provided', () => {
+      const onBudgetExceeded = vi.fn();
+      const onFinish = createBudgetGuardedOnFinish({ maxTokens: 1000, onBudgetExceeded }, 'gpt-4o');
+
+      onFinish({
+        usage: { promptTokens: 600, completionTokens: 500 },
+      });
+
+      expect(onBudgetExceeded).toHaveBeenCalledWith(
+        expect.objectContaining({ totalTokens: 1100 }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe('createStepCounter', () => {
+    it('increments count correctly', () => {
+      const counter = createStepCounter({ maxSteps: 5 });
+
+      expect(counter.getCount()).toBe(0);
+      expect(counter.increment()).toBe(1);
+      expect(counter.increment()).toBe(2);
+      expect(counter.getCount()).toBe(2);
+    });
+
+    it('calls onLimitReached when limit is reached', () => {
+      const onLimitReached = vi.fn();
+      const counter = createStepCounter({ maxSteps: 3, onLimitReached });
+
+      counter.increment();
+      counter.increment();
+      expect(onLimitReached).not.toHaveBeenCalled();
+
+      counter.increment();
+      expect(onLimitReached).toHaveBeenCalledWith(3);
+    });
+
+    it('calls onLimitReached only once', () => {
+      const onLimitReached = vi.fn();
+      const counter = createStepCounter({ maxSteps: 2, onLimitReached });
+
+      counter.increment();
+      counter.increment();
+      counter.increment();
+      counter.increment();
+
+      expect(onLimitReached).toHaveBeenCalledTimes(1);
+    });
+
+    it('shouldStop returns true when strategy is stop and limit reached', () => {
+      const counter = createStepCounter({ maxSteps: 2, strategy: 'stop' });
+
+      counter.increment();
+      expect(counter.shouldStop()).toBe(false);
+
+      counter.increment();
+      expect(counter.shouldStop()).toBe(true);
+    });
+
+    it('shouldStop returns false when strategy is warn', () => {
+      const counter = createStepCounter({ maxSteps: 2, strategy: 'warn' });
+
+      counter.increment();
+      counter.increment();
+
+      expect(counter.shouldStop()).toBe(false);
+      expect(counter.shouldWarn()).toBe(true);
+    });
+
+    it('shouldStop returns false when strategy is continue', () => {
+      const counter = createStepCounter({ maxSteps: 2, strategy: 'continue' });
+
+      counter.increment();
+      counter.increment();
+
+      expect(counter.shouldStop()).toBe(false);
+      expect(counter.shouldWarn()).toBe(false);
+    });
+
+    it('reset clears the counter', () => {
+      const onLimitReached = vi.fn();
+      const counter = createStepCounter({ maxSteps: 2, onLimitReached });
+
+      counter.increment();
+      counter.increment();
+      expect(counter.getCount()).toBe(2);
+      expect(onLimitReached).toHaveBeenCalledTimes(1);
+
+      counter.reset();
+      expect(counter.getCount()).toBe(0);
+
+      // Should call onLimitReached again after reset
+      counter.increment();
+      counter.increment();
+      expect(onLimitReached).toHaveBeenCalledTimes(2);
+    });
+
+    it('defaults strategy to stop', () => {
+      const counter = createStepCounter({ maxSteps: 1 });
+
+      counter.increment();
+
+      expect(counter.shouldStop()).toBe(true);
+    });
+  });
+
+  describe('createStepLimitCondition', () => {
+    it('returns false when under limit', () => {
+      const condition = createStepLimitCondition(5);
+
+      expect(condition({ steps: 0 })).toBe(false);
+      expect(condition({ steps: 2 })).toBe(false);
+      expect(condition({ steps: 4 })).toBe(false);
+    });
+
+    it('returns true when at limit', () => {
+      const condition = createStepLimitCondition(5);
+
+      expect(condition({ steps: 5 })).toBe(true);
+    });
+
+    it('returns true when over limit', () => {
+      const condition = createStepLimitCondition(5);
+
+      expect(condition({ steps: 6 })).toBe(true);
+      expect(condition({ steps: 10 })).toBe(true);
+    });
+  });
+
+  describe('withStepLimit', () => {
+    it('increments counter before each call', async () => {
+      const fn = vi.fn().mockResolvedValue('result');
+      const limitedFn = withStepLimit({ maxSteps: 5, strategy: 'stop' }, fn);
+
+      await limitedFn('arg1');
+      await limitedFn('arg2');
+
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it('throws StepLimitExceededError when limit reached with stop strategy', async () => {
+      const fn = vi.fn().mockResolvedValue('result');
+      const limitedFn = withStepLimit({ maxSteps: 2, strategy: 'stop' }, fn);
+
+      await limitedFn();
+      await limitedFn();
+
+      await expect(limitedFn()).rejects.toThrowError(StepLimitExceededError);
+    });
+
+    it('does not throw when strategy is continue', async () => {
+      const fn = vi.fn().mockResolvedValue('result');
+      const limitedFn = withStepLimit({ maxSteps: 2, strategy: 'continue' }, fn);
+
+      await limitedFn();
+      await limitedFn();
+      await expect(limitedFn()).resolves.toBe('result');
+    });
+  });
+
+  describe('stepLimitExceededError', () => {
+    it('has correct properties', () => {
+      const error = new StepLimitExceededError(5, 3);
+
+      expect(error.name).toBe('StepLimitExceededError');
+      expect(error.stepCount).toBe(5);
+      expect(error.maxSteps).toBe(3);
+      expect(error.message).toContain('5/3');
+    });
+  });
+
+  describe('createSmoothStreamTransform', () => {
+    it('returns default configuration when no config provided', () => {
+      const transform = createSmoothStreamTransform();
+
+      expect(transform.delayInMs).toBe(10);
+      expect(transform.chunking).toBe('word');
+    });
+
+    it('respects custom delay', () => {
+      const transform = createSmoothStreamTransform({ delayInMs: 50 });
+
+      expect(transform.delayInMs).toBe(50);
+    });
+
+    it('respects custom chunking', () => {
+      const transform = createSmoothStreamTransform({ chunking: 'sentence' });
+
+      expect(transform.chunking).toBe('sentence');
+    });
+  });
+
+  describe('splitIntoChunks', () => {
+    it('splits by word', () => {
+      const chunks = splitIntoChunks('Hello world foo bar', 'word');
+
+      expect(chunks).toStrictEqual(['Hello', 'world', 'foo', 'bar']);
+    });
+
+    it('splits by line', () => {
+      const chunks = splitIntoChunks('Line 1\nLine 2\nLine 3', 'line');
+
+      expect(chunks).toStrictEqual(['Line 1', 'Line 2', 'Line 3']);
+    });
+
+    it('splits by sentence', () => {
+      const chunks = splitIntoChunks('First sentence. Second sentence! Third?', 'sentence');
+
+      expect(chunks.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('respects minimum chunk size', () => {
+      const chunks = splitIntoChunks('a b c d e f', 'word', 5);
+
+      // All chunks should be at least 5 characters (except possibly the last)
+      for (let i = 0; i < chunks.length - 1; i++) {
+        expect(chunks[i]!.length).toBeGreaterThanOrEqual(5);
+      }
+    });
+
+    it('filters empty chunks', () => {
+      const chunks = splitIntoChunks('  Hello   world  ', 'word');
+
+      expect(chunks.every(chunk => chunk.length > 0)).toBe(true);
+    });
+  });
+
+  describe('smoothTextGenerator', () => {
+    it('yields chunks from text', async () => {
+      const chunks: string[] = [];
+
+      for await (const chunk of smoothTextGenerator('Hello world', { delayInMs: 0 })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks.join(' ')).toContain('Hello');
+    });
+
+    it('respects delay setting', async () => {
+      const startTime = Date.now();
+      const chunks: string[] = [];
+
+      for await (const chunk of smoothTextGenerator('a b c', { delayInMs: 10 })) {
+        chunks.push(chunk);
+      }
+
+      const elapsed = Date.now() - startTime;
+      // Should take at least (chunks.length - 1) * 10ms
+      expect(elapsed).toBeGreaterThanOrEqual((chunks.length - 1) * 10 - 5);
+    });
+  });
+
+  describe('withSmoothStream', () => {
+    it('adds delay to async iterable', async () => {
+      async function* source() {
+        yield 'chunk1';
+        yield 'chunk2';
+      }
+
+      const startTime = Date.now();
+      const chunks: string[] = [];
+
+      for await (const chunk of withSmoothStream(source(), { delayInMs: 10 })) {
+        chunks.push(chunk);
+      }
+
+      const elapsed = Date.now() - startTime;
+      expect(chunks).toStrictEqual(['chunk1', 'chunk2']);
+      expect(elapsed).toBeGreaterThanOrEqual(10);
+    });
+  });
+
+  describe('createStreamController', () => {
+    it('creates controller with empty config', () => {
+      const controller = createStreamController();
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard).toBeUndefined();
+      expect(config.stepLimit).toBeUndefined();
+      expect(config.smoothStream).toBeUndefined();
+    });
+
+    it('creates controller with initial config', () => {
+      const controller = createStreamController({
+        smoothStream: { delayInMs: 20 },
+      });
+      const config = controller.getConfig();
+
+      expect(config.smoothStream?.delayInMs).toBe(20);
+    });
+
+    it('chains withBudgetGuard', () => {
+      const controller = createStreamController().withBudgetGuard({ maxTokens: 50000 });
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(50000);
+    });
+
+    it('chains withStepLimit', () => {
+      const controller = createStreamController().withStepLimit({ maxSteps: 10 });
+      const config = controller.getConfig();
+
+      expect(config.stepLimit?.maxSteps).toBe(10);
+    });
+
+    it('chains withSmoothStream', () => {
+      const controller = createStreamController().withSmoothStream({
+        delayInMs: 30,
+        chunking: 'sentence',
+      });
+      const config = controller.getConfig();
+
+      expect(config.smoothStream?.delayInMs).toBe(30);
+      expect(config.smoothStream?.chunking).toBe('sentence');
+    });
+
+    it('chains multiple configurations', () => {
+      const controller = createStreamController()
+        .withBudgetGuard({ maxTokens: 100000, maxCost: 10.0 })
+        .withStepLimit({ maxSteps: 10, strategy: 'stop' })
+        .withSmoothStream({ delayInMs: 20 });
+
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(100000);
+      expect(config.budgetGuard?.maxCost).toBe(10.0);
+      expect(config.stepLimit?.maxSteps).toBe(10);
+      expect(config.stepLimit?.strategy).toBe('stop');
+      expect(config.smoothStream?.delayInMs).toBe(20);
+    });
+
+    it('merges budget guard configs', () => {
+      const controller = createStreamController()
+        .withBudgetGuard({ maxTokens: 50000 })
+        .withBudgetGuard({ maxCost: 5.0 });
+
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(50000);
+      expect(config.budgetGuard?.maxCost).toBe(5.0);
+    });
+
+    it('merges cost tables', () => {
+      const controller = createStreamController()
+        .withBudgetGuard({
+          costTable: { 'model-a': { input: 0.001, output: 0.002 } },
+        })
+        .withBudgetGuard({
+          costTable: { 'model-b': { input: 0.003, output: 0.004 } },
+        });
+
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.costTable?.['model-a']).toBeDefined();
+      expect(config.budgetGuard?.costTable?.['model-b']).toBeDefined();
+    });
+
+    it('replaces step limit config', () => {
+      const controller = createStreamController()
+        .withStepLimit({ maxSteps: 5, strategy: 'warn' })
+        .withStepLimit({ maxSteps: 10, strategy: 'stop' });
+
+      const config = controller.getConfig();
+
+      expect(config.stepLimit?.maxSteps).toBe(10);
+      expect(config.stepLimit?.strategy).toBe('stop');
+    });
+
+    it('returns immutable config copies', () => {
+      const controller = createStreamController().withBudgetGuard({ maxTokens: 100 });
+
+      const config1 = controller.getConfig();
+      const config2 = controller.getConfig();
+
+      expect(config1).not.toBe(config2);
+      expect(config1).toStrictEqual(config2);
+    });
+  });
+
+  describe('mergeStreamConfigs', () => {
+    it('merges multiple configs', () => {
+      const config1 = createStreamController().withBudgetGuard({ maxTokens: 100000 }).getConfig();
+
+      const config2 = createStreamController().withStepLimit({ maxSteps: 10 }).getConfig();
+
+      const config3 = createStreamController().withSmoothStream({ delayInMs: 20 }).getConfig();
+
+      const merged = mergeStreamConfigs([config1, config2, config3]);
+
+      expect(merged.budgetGuard?.maxTokens).toBe(100000);
+      expect(merged.stepLimit?.maxSteps).toBe(10);
+      expect(merged.smoothStream?.delayInMs).toBe(20);
+    });
+
+    it('later configs override earlier ones', () => {
+      const config1 = createStreamController().withStepLimit({ maxSteps: 5 }).getConfig();
+
+      const config2 = createStreamController().withStepLimit({ maxSteps: 10 }).getConfig();
+
+      const merged = mergeStreamConfigs([config1, config2]);
+
+      expect(merged.stepLimit?.maxSteps).toBe(10);
+    });
+  });
+
+  describe('createDevStreamController', () => {
+    it('returns controller with development presets', () => {
+      const controller = createDevStreamController();
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(500000);
+      expect(config.budgetGuard?.maxCost).toBe(50.0);
+      expect(config.stepLimit?.maxSteps).toBe(20);
+      expect(config.stepLimit?.strategy).toBe('warn');
+      expect(config.smoothStream?.delayInMs).toBe(5);
+    });
+  });
+
+  describe('createProdStreamController', () => {
+    it('returns controller with production defaults', () => {
+      const controller = createProdStreamController();
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(100000);
+      expect(config.budgetGuard?.maxCost).toBe(10.0);
+      expect(config.stepLimit?.maxSteps).toBe(10);
+      expect(config.stepLimit?.strategy).toBe('stop');
+      expect(config.smoothStream?.delayInMs).toBe(10);
+    });
+
+    it('accepts custom options', () => {
+      const onBudgetExceeded = vi.fn();
+      const onStepLimitReached = vi.fn();
+
+      const controller = createProdStreamController({
+        maxTokens: 200000,
+        maxCost: 20.0,
+        maxSteps: 15,
+        onBudgetExceeded,
+        onStepLimitReached,
+      });
+
+      const config = controller.getConfig();
+
+      expect(config.budgetGuard?.maxTokens).toBe(200000);
+      expect(config.budgetGuard?.maxCost).toBe(20.0);
+      expect(config.stepLimit?.maxSteps).toBe(15);
+      expect(config.budgetGuard?.onBudgetExceeded).toBe(onBudgetExceeded);
+      expect(config.stepLimit?.onLimitReached).toBe(onStepLimitReached);
+    });
+  });
+});