ai-functions 2.0.2 → 2.1.3

package/test/batch-background.test.js

@@ -0,0 +1,352 @@
+/**
+ * Tests for batch and background processing modes
+ *
+ * Batch mode: fn.batch([inputs]) - Process many inputs at ~50% discount
+ * Background mode: fn(..., { mode: 'background' }) - Returns job ID immediately
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// ============================================================================
+// Mock implementations
+// ============================================================================
+const mockBatchProcess = vi.fn();
+const mockBackgroundProcess = vi.fn();
+/**
+ * Create a mock function with batch support
+ */
+function createMockFunctionWithBatch(defaultHandler) {
+    const fn = async (prompt, options) => {
+        if (options?.mode === 'background') {
+            return mockBackgroundProcess(prompt, options);
+        }
+        return defaultHandler(prompt);
+    };
+    // Add batch method
+    fn.batch = async (inputs) => {
+        return mockBatchProcess(inputs);
+    };
+    return fn;
+}
+/**
+ * Create a tagged template function with batch support
+ */
+function createMockTemplateFunctionWithBatch(defaultHandler) {
+    function fn(promptOrStrings, ...args) {
+        let prompt;
+        if (Array.isArray(promptOrStrings) && 'raw' in promptOrStrings) {
+            prompt = promptOrStrings.reduce((acc, str, i) => {
+                return acc + str + (args[i] ?? '');
+            }, '');
+        }
+        else {
+            prompt = promptOrStrings;
+        }
+        return defaultHandler(prompt);
+    }
+    // Add batch method
+    fn.batch = async (inputs) => {
+        return mockBatchProcess(inputs);
+    };
+    return fn;
+}
+// ============================================================================
+// Batch mode tests
+// ============================================================================
+describe('batch mode', () => {
+    beforeEach(() => {
+        mockBatchProcess.mockReset();
+    });
+    describe('write.batch()', () => {
+        it('processes multiple prompts in batch', async () => {
+            const write = createMockFunctionWithBatch(async () => 'Generated content');
+            const prompts = [
+                'blog post about TypeScript',
+                'blog post about React',
+                'blog post about Next.js',
+            ];
+            mockBatchProcess.mockResolvedValue([
+                'TypeScript content...',
+                'React content...',
+                'Next.js content...',
+            ]);
+            const results = await write.batch(prompts);
+            expect(mockBatchProcess).toHaveBeenCalledWith(prompts);
+            expect(results).toHaveLength(3);
+        });
+        it('processes object inputs with context', async () => {
+            const write = createMockFunctionWithBatch(async () => 'Generated content');
+            const brand = { voice: 'professional', audience: 'developers' };
+            const titles = ['Getting Started', 'Advanced Patterns', 'Best Practices'];
+            const inputs = titles.map(title => ({
+                title,
+                brand,
+                tone: 'technical',
+            }));
+            mockBatchProcess.mockResolvedValue([
+                'Getting Started content...',
+                'Advanced Patterns content...',
+                'Best Practices content...',
+            ]);
+            const results = await write.batch(inputs);
+            expect(mockBatchProcess).toHaveBeenCalledWith(inputs);
+            expect(results).toHaveLength(3);
+        });
+        it('returns results in same order as inputs', async () => {
+            const write = createMockFunctionWithBatch(async () => 'content');
+            const inputs = ['first', 'second', 'third'];
+            mockBatchProcess.mockResolvedValue([
+                'Result for first',
+                'Result for second',
+                'Result for third',
+            ]);
+            const results = await write.batch(inputs);
+            expect(results[0]).toContain('first');
+            expect(results[1]).toContain('second');
+            expect(results[2]).toContain('third');
+        });
+    });
+    describe('list.batch()', () => {
+        it('generates multiple lists in batch', async () => {
+            const list = createMockFunctionWithBatch(async () => ['item']);
+            mockBatchProcess.mockResolvedValue([
+                ['TypeScript tip 1', 'TypeScript tip 2'],
+                ['React tip 1', 'React tip 2'],
+                ['Next.js tip 1', 'Next.js tip 2'],
+            ]);
+            const results = await list.batch([
+                '3 TypeScript tips',
+                '3 React tips',
+                '3 Next.js tips',
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results[0]).toEqual(['TypeScript tip 1', 'TypeScript tip 2']);
+        });
+    });
+    describe('code.batch()', () => {
+        it('generates multiple code snippets in batch', async () => {
+            const code = createMockFunctionWithBatch(async () => 'code');
+            mockBatchProcess.mockResolvedValue([
+                'function validateEmail(email) { ... }',
+                'function validatePhone(phone) { ... }',
+                'function validateUrl(url) { ... }',
+            ]);
+            const results = await code.batch([
+                { description: 'email validator', language: 'typescript' },
+                { description: 'phone validator', language: 'typescript' },
+                { description: 'url validator', language: 'typescript' },
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results[0]).toContain('validateEmail');
+        });
+    });
+    describe('batch with options', () => {
+        it('accepts batch-level options', async () => {
+            const write = createMockFunctionWithBatch(async () => 'content');
+            // Simulating batch with options
+            const mockBatchWithOptions = vi.fn().mockResolvedValue(['r1', 'r2']);
+            const inputs = ['prompt1', 'prompt2'];
+            const options = { model: 'claude-opus-4-5' };
+            await mockBatchWithOptions(inputs, options);
+            expect(mockBatchWithOptions).toHaveBeenCalledWith(inputs, options);
+        });
+        it('supports priority option for urgent batches', async () => {
+            const mockBatchWithPriority = vi.fn().mockResolvedValue(['result']);
+            await mockBatchWithPriority(['prompt'], { priority: 'high' });
+            expect(mockBatchWithPriority).toHaveBeenCalledWith(['prompt'], expect.objectContaining({ priority: 'high' }));
+        });
+    });
+});
+// ============================================================================
+// Background mode tests
+// ============================================================================
+describe('background mode', () => {
+    beforeEach(() => {
+        mockBackgroundProcess.mockReset();
+    });
+    it('returns job ID immediately', async () => {
+        const write = createMockFunctionWithBatch(async () => 'content');
+        mockBackgroundProcess.mockResolvedValue({
+            jobId: 'job_abc123',
+            status: 'pending',
+        });
+        const job = await write('long form article', { mode: 'background' });
+        expect(mockBackgroundProcess).toHaveBeenCalledWith('long form article', expect.objectContaining({ mode: 'background' }));
+        expect(job).toHaveProperty('jobId');
+        expect(job.status).toBe('pending');
+    });
+    it('can check job status', async () => {
+        const mockGetJobStatus = vi.fn();
+        // Simulating job status check
+        mockGetJobStatus.mockResolvedValueOnce({ status: 'processing' });
+        mockGetJobStatus.mockResolvedValueOnce({ status: 'completed', result: 'Generated content' });
+        const status1 = await mockGetJobStatus('job_abc123');
+        expect(status1.status).toBe('processing');
+        const status2 = await mockGetJobStatus('job_abc123');
+        expect(status2.status).toBe('completed');
+        expect(status2.result).toBe('Generated content');
+    });
+    it('supports webhook callback', async () => {
+        const write = createMockFunctionWithBatch(async () => 'content');
+        mockBackgroundProcess.mockResolvedValue({
+            jobId: 'job_xyz789',
+            status: 'pending',
+        });
+        await write('content', {
+            mode: 'background',
+            webhook: 'https://myapp.com/webhooks/ai-complete',
+        });
+        expect(mockBackgroundProcess).toHaveBeenCalledWith('content', expect.objectContaining({
+            mode: 'background',
+            webhook: 'https://myapp.com/webhooks/ai-complete',
+        }));
+    });
+    it('supports polling for result', async () => {
+        // Simulating a poll function
+        const mockPollForResult = vi.fn();
+        mockPollForResult.mockImplementation(async (jobId) => {
+            // Simulate polling - would normally check periodically
+            return { status: 'completed', result: 'Final result' };
+        });
+        const result = await mockPollForResult('job_abc123');
+        expect(result.status).toBe('completed');
+        expect(result.result).toBe('Final result');
+    });
+});
+// ============================================================================
+// Combined batch and background
+// ============================================================================
+describe('batch + background mode', () => {
+    it('can run batch in background', async () => {
+        const mockBatchBackground = vi.fn();
+        mockBatchBackground.mockResolvedValue({
+            jobId: 'batch_job_123',
+            status: 'pending',
+            inputCount: 100,
+        });
+        // Large batch job in background
+        const job = await mockBatchBackground(Array(100).fill('Generate content'), { mode: 'background' });
+        expect(job.jobId).toBe('batch_job_123');
+        expect(job.inputCount).toBe(100);
+    });
+    it('tracks progress of background batch', async () => {
+        const mockBatchProgress = vi.fn();
+        mockBatchProgress
+            .mockResolvedValueOnce({ status: 'processing', completed: 10, total: 100 })
+            .mockResolvedValueOnce({ status: 'processing', completed: 50, total: 100 })
+            .mockResolvedValueOnce({ status: 'completed', completed: 100, total: 100 });
+        const p1 = await mockBatchProgress('batch_job_123');
+        expect(p1.completed).toBe(10);
+        const p2 = await mockBatchProgress('batch_job_123');
+        expect(p2.completed).toBe(50);
+        const p3 = await mockBatchProgress('batch_job_123');
+        expect(p3.status).toBe('completed');
+    });
+});
+// ============================================================================
+// Batch pricing and limits
+// ============================================================================
+describe('batch characteristics', () => {
+    it('batch provides cost savings (documentation test)', () => {
+        // This documents expected behavior
+        const batchInfo = {
+            discount: '50%',
+            turnaround: '24 hours max',
+            minBatchSize: 1,
+            maxBatchSize: 10000,
+        };
+        expect(batchInfo.discount).toBe('50%');
+        expect(batchInfo.turnaround).toBe('24 hours max');
+    });
+    it('batch handles errors gracefully', async () => {
+        const mockBatchWithErrors = vi.fn();
+        // Some items succeed, some fail
+        mockBatchWithErrors.mockResolvedValue({
+            results: [
+                { index: 0, status: 'success', result: 'Content 1' },
+                { index: 1, status: 'error', error: 'Content policy violation' },
+                { index: 2, status: 'success', result: 'Content 3' },
+            ],
+            summary: { succeeded: 2, failed: 1 },
+        });
+        const response = await mockBatchWithErrors(['p1', 'p2', 'p3']);
+        expect(response.summary.succeeded).toBe(2);
+        expect(response.summary.failed).toBe(1);
+        expect(response.results[1].status).toBe('error');
+    });
+});
+// ============================================================================
+// Use cases from README
+// ============================================================================
+describe('batch use cases', () => {
+    beforeEach(() => {
+        mockBatchProcess.mockReset();
+    });
+    it('content generation at scale', async () => {
+        const write = createMockFunctionWithBatch(async () => 'content');
+        // Generate blog posts for 100 topics
+        const topics = Array(100)
+            .fill(null)
+            .map((_, i) => `Topic ${i + 1}`);
+        const inputs = topics.map(topic => ({
+            topic,
+            length: 'medium',
+            style: 'informative',
+        }));
+        mockBatchProcess.mockResolvedValue(topics.map(t => `Blog post about ${t}...`));
+        const posts = await write.batch(inputs);
+        expect(posts).toHaveLength(100);
+    });
+    it('product description generation', async () => {
+        const write = createMockFunctionWithBatch(async () => 'description');
+        const products = [
+            { name: 'Widget Pro', category: 'tools', features: ['durable', 'lightweight'] },
+            { name: 'Gadget Plus', category: 'electronics', features: ['wireless', 'rechargeable'] },
+        ];
+        mockBatchProcess.mockResolvedValue([
+            'Widget Pro is a durable, lightweight tool...',
+            'Gadget Plus is a wireless, rechargeable electronic...',
+        ]);
+        const descriptions = await write.batch(products.map(p => ({
+            prompt: `product description for ${p.name}`,
+            product: p,
+        })));
+        expect(descriptions).toHaveLength(2);
+        expect(descriptions[0]).toContain('Widget Pro');
+    });
+    it('code generation for multiple functions', async () => {
+        const code = createMockFunctionWithBatch(async () => 'code');
+        const functions = [
+            { name: 'validateEmail', description: 'Validate email format' },
+            { name: 'validatePhone', description: 'Validate phone number' },
+            { name: 'validateUrl', description: 'Validate URL format' },
+        ];
+        mockBatchProcess.mockResolvedValue(functions.map(f => `function ${f.name}(value) { ... }`));
+        const implementations = await code.batch(functions.map(f => ({
+            description: f.description,
+            functionName: f.name,
+            language: 'typescript',
+        })));
+        expect(implementations).toHaveLength(3);
+        functions.forEach((f, i) => {
+            expect(implementations[i]).toContain(f.name);
+        });
+    });
+});
+// ============================================================================
+// Error handling
+// ============================================================================
+describe('batch error handling', () => {
+    beforeEach(() => {
+        mockBatchProcess.mockReset();
+    });
+    it('handles empty input array', async () => {
+        const write = createMockFunctionWithBatch(async () => 'content');
+        mockBatchProcess.mockResolvedValue([]);
+        const results = await write.batch([]);
+        expect(results).toEqual([]);
+    });
+    it('propagates batch-level errors', async () => {
+        const write = createMockFunctionWithBatch(async () => 'content');
+        mockBatchProcess.mockRejectedValue(new Error('Batch quota exceeded'));
+        await expect(write.batch(['prompt'])).rejects.toThrow('Batch quota exceeded');
+    });
+});

package/test/batch-blog-posts.test.js

@@ -0,0 +1,293 @@
+/**
+ * Batch Blog Post Generation Test
+ *
+ * Tests the batch processing workflow where:
+ * 1. list`10 blog post titles` executes immediately
+ * 2. The mapped write operations are deferred to a batch
+ * 3. The batch is submitted to the provider (OpenAI/Anthropic)
+ *
+ * @example
+ * ```ts
+ * const titles = await list`10 blog post titles about building startups in 2026`
+ * const posts = titles.map(title => batch.add(write`blog post about ${title}`))
+ * const job = await batch.submit()
+ * const results = await batch.wait()
+ * ```
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createBatch, withBatch, } from '../src/batch-queue.js';
+// Import memory adapter to register it
+import '../src/batch/memory.js';
+import { configureMemoryAdapter, clearBatches } from '../src/batch/memory.js';
+// ============================================================================
+// Mock Setup
+// ============================================================================
+// Mock the generate functions
+vi.mock('../src/generate.js', () => ({
+    generateObject: vi.fn().mockImplementation(async ({ prompt, schema }) => {
+        // Simulate list generation
+        if (schema?.items) {
+            return {
+                object: {
+                    items: [
+                        'How AI is Revolutionizing Startup Fundraising in 2026',
+                        'The Rise of Solo Founders: Building $10M ARR Companies Alone',
+                        'Why Remote-First is Non-Negotiable for 2026 Startups',
+                        'Sustainable Growth vs Hypergrowth: The 2026 Paradigm Shift',
+                        'Building in Public: How Transparency Became a Competitive Advantage',
+                        'The API-First Startup: Lessons from 2026 Unicorns',
+                        'From Side Project to Series A: The 2026 Playbook',
+                        'Climate Tech Startups: The Hottest Sector of 2026',
+                        'The Death of Traditional MVPs: Ship Faster, Learn Faster',
+                        'Community-Led Growth: The New GTM Strategy for 2026',
+                    ],
+                },
+            };
+        }
+        // Simulate blog post generation
+        if (prompt.includes('blog post about')) {
+            const titleMatch = prompt.match(/blog post about (.+)/);
+            const title = titleMatch?.[1] || 'Unknown Topic';
+            return {
+                object: {
+                    text: `# ${title}\n\nThis is a comprehensive blog post about ${title}.\n\n## Introduction\n\nIn 2026, the startup landscape continues to evolve...\n\n## Key Takeaways\n\n1. Innovation is key\n2. Focus on customer value\n3. Build sustainable businesses\n\n## Conclusion\n\nThe future of startups is bright for those who adapt.`,
+                },
+            };
+        }
+        return { object: { result: 'Generated content' } };
+    }),
+    generateText: vi.fn().mockImplementation(async ({ prompt }) => {
+        // Simulate blog post text generation
+        if (prompt.includes('blog post about')) {
+            const titleMatch = prompt.match(/blog post about (.+)/);
+            const title = titleMatch?.[1] || 'Unknown Topic';
+            return {
+                text: `# ${title}\n\nThis is a comprehensive blog post about ${title}.\n\n## Introduction\n\nIn 2026, the startup landscape continues to evolve rapidly. Entrepreneurs are finding new ways to build, scale, and succeed.\n\n## The State of Startups in 2026\n\nThe ecosystem has matured significantly. AI tools have become indispensable, funding patterns have shifted, and remote work is now the default.\n\n## Key Strategies for Success\n\n1. **Leverage AI Wisely** - Use AI as a multiplier, not a replacement\n2. **Build Community First** - Your early adopters are your growth engine\n3. **Focus on Unit Economics** - Hypergrowth without sustainability is dead\n4. **Embrace Transparency** - Building in public creates trust and accountability\n\n## Practical Steps\n\n- Start with a problem you deeply understand\n- Validate with paying customers, not surveys\n- Build the smallest thing that delivers value\n- Iterate based on real usage data\n\n## Conclusion\n\nBuilding a startup in 2026 requires a blend of traditional business fundamentals and modern tools. The founders who succeed will be those who can navigate this balance effectively.`,
+            };
+        }
+        return { text: 'Generated text content' };
+    }),
+}));
+// ============================================================================
+// Test Helpers
+// ============================================================================
+/**
+ * Simulate the list template function
+ */
+async function mockList(prompt) {
+    const { generateObject } = await import('../src/generate.js');
+    const result = await generateObject({
+        model: 'sonnet',
+        schema: { items: ['List items'] },
+        prompt,
+    });
+    return result.object.items;
+}
+// ============================================================================
+// Tests
+// ============================================================================
+describe('Batch Blog Post Generation', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        clearBatches();
+        // Use default handler that calls the mock
+        configureMemoryAdapter({});
+    });
+    afterEach(() => {
+        clearBatches();
+    });
+    describe('list` immediate execution', () => {
+        it('list` executes immediately and returns titles', async () => {
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            expect(titles).toHaveLength(10);
+            expect(titles[0]).toBe('How AI is Revolutionizing Startup Fundraising in 2026');
+            expect(titles[9]).toBe('Community-Led Growth: The New GTM Strategy for 2026');
+        });
+    });
+    describe('batch processing workflow', () => {
+        it('creates batch queue and adds items', async () => {
+            const batch = createBatch({ provider: 'openai', model: 'gpt-4o' });
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            // Add each title to the batch
+            const items = titles.map((title) => batch.add(`Write a comprehensive blog post about: ${title}`, {
+                customId: title.slice(0, 50).replace(/\s+/g, '-').toLowerCase(),
+            }));
+            expect(batch.size).toBe(10);
+            expect(items).toHaveLength(10);
+            expect(items[0].status).toBe('pending');
+        });
+        it('submits batch and returns job info', async () => {
+            const batch = createBatch({ provider: 'openai', model: 'gpt-4o' });
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            titles.forEach((title) => batch.add(`Write a comprehensive blog post about: ${title}`));
+            const { job, completion } = await batch.submit();
+            expect(job.id).toMatch(/^batch_memory_/);
+            expect(job.provider).toBe('openai');
+            expect(job.totalItems).toBe(10);
+            expect(job.status).toBe('pending');
+            // Wait for completion
+            const results = await completion;
+            expect(results).toHaveLength(10);
+        });
+        it('waits for batch completion and returns results', async () => {
+            const batch = createBatch({ provider: 'openai', model: 'gpt-4o' });
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            titles.forEach((title) => batch.add(`Write a comprehensive blog post about: ${title}`));
+            await batch.submit();
+            const results = await batch.wait();
+            expect(results).toHaveLength(10);
+            expect(results.every((r) => r.status === 'completed')).toBe(true);
+            expect(results[0].result).toBeDefined();
+        });
+        it('processes items in order', async () => {
+            const batch = createBatch({ provider: 'openai' });
+            const titles = ['First', 'Second', 'Third'];
+            const items = titles.map((title, i) => batch.add(`Write about: ${title}`, { customId: `item_${i}` }));
+            await batch.submit();
+            const results = await batch.wait();
+            expect(results[0].id).toBe('item_0');
+            expect(results[1].id).toBe('item_1');
+            expect(results[2].id).toBe('item_2');
+        });
+    });
+    describe('withBatchQueue helper', () => {
+        it('provides convenient batch execution', async () => {
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            const results = await withBatch((batch) => titles.map((title) => batch.add(`Write a blog post about: ${title}`)), { provider: 'openai', model: 'gpt-4o' });
+            expect(results).toHaveLength(10);
+            expect(results.every((r) => r.status === 'completed')).toBe(true);
+        });
+    });
+    describe('batch status tracking', () => {
+        it('tracks completion progress', async () => {
+            const batch = createBatch({ provider: 'openai' });
+            batch.add('Write post 1');
+            batch.add('Write post 2');
+            batch.add('Write post 3');
+            const { job } = await batch.submit();
+            expect(job.completedItems).toBe(0);
+            // Wait for completion
+            await batch.wait();
+            const finalStatus = await batch.getStatus();
+            expect(finalStatus.status).toBe('completed');
+            expect(finalStatus.completedItems).toBe(3);
+        });
+    });
+    describe('error handling', () => {
+        it('handles partial failures', async () => {
+            // Configure adapter to fail 30% of requests
+            configureMemoryAdapter({ failureRate: 0.3 });
+            const batch = createBatch({ provider: 'openai' });
+            for (let i = 0; i < 10; i++) {
+                batch.add(`Write post ${i}`);
+            }
+            await batch.submit();
+            const results = await batch.wait();
+            // Some should fail, some should succeed
+            const succeeded = results.filter((r) => r.status === 'completed').length;
+            const failed = results.filter((r) => r.status === 'failed').length;
+            expect(succeeded + failed).toBe(10);
+            // With 30% failure rate, expect roughly 3 failures (with some variance)
+            expect(failed).toBeGreaterThanOrEqual(0);
+            expect(failed).toBeLessThanOrEqual(10);
+        });
+        it('prevents adding items after submission', async () => {
+            const batch = createBatch({ provider: 'openai' });
+            batch.add('Write post 1');
+            await batch.submit();
+            expect(() => batch.add('Write post 2')).toThrow('Cannot add items to a submitted batch');
+        });
+        it('prevents double submission', async () => {
+            const batch = createBatch({ provider: 'openai' });
+            batch.add('Write post 1');
+            await batch.submit();
+            await expect(batch.submit()).rejects.toThrow('Batch has already been submitted');
+        });
+        it('prevents empty batch submission', async () => {
+            const batch = createBatch({ provider: 'openai' });
+            await expect(batch.submit()).rejects.toThrow('Cannot submit empty batch');
+        });
+    });
+    describe('batch with custom handler', () => {
+        it('uses custom handler for processing', async () => {
+            const customHandler = vi.fn().mockImplementation(async (item) => {
+                return `Custom result for: ${item.prompt}`;
+            });
+            configureMemoryAdapter({ handler: customHandler });
+            const batch = createBatch({ provider: 'openai' });
+            batch.add('Topic 1');
+            batch.add('Topic 2');
+            await batch.submit();
+            const results = await batch.wait();
+            expect(customHandler).toHaveBeenCalledTimes(2);
+            expect(results[0].result).toBe('Custom result for: Topic 1');
+            expect(results[1].result).toBe('Custom result for: Topic 2');
+        });
+    });
+    describe('full workflow: list → map → batch', () => {
+        it('executes the complete blog post generation workflow', async () => {
+            // Step 1: Get titles (executes immediately)
+            const titles = await mockList('10 blog post titles about building startups in 2026');
+            expect(titles).toHaveLength(10);
+            // Step 2: Create batch for blog posts (deferred)
+            const batch = createBatch({
+                provider: 'openai',
+                model: 'gpt-4o',
+                metadata: { task: 'blog-generation', topic: 'startups-2026' },
+            });
+            // Step 3: Map titles to batch items
+            const blogItems = titles.map((title, index) => batch.add(`Write a comprehensive blog post about: ${title}`, {
+                customId: `blog-${index}`,
+                metadata: { title },
+            }));
+            expect(batch.size).toBe(10);
+            expect(blogItems.every((item) => item.status === 'pending')).toBe(true);
+            // Step 4: Submit the batch
+            const { job, completion } = await batch.submit();
+            expect(job.id).toBeDefined();
+            expect(job.totalItems).toBe(10);
+            expect(batch.isSubmitted).toBe(true);
+            // Step 5: Wait for results
+            const results = await completion;
+            expect(results).toHaveLength(10);
+            expect(results.every((r) => r.status === 'completed')).toBe(true);
+            // Verify results have blog post content
+            for (const result of results) {
+                expect(result.result).toBeDefined();
+                expect(typeof result.result).toBe('string');
+                // Blog posts should have some content
+                expect(result.result.length).toBeGreaterThan(100);
+            }
+            // Verify items are updated after completion
+            expect(blogItems.every((item) => item.status === 'completed')).toBe(true);
+        });
+    });
+});
+describe('Provider-specific batch behavior', () => {
+    beforeEach(() => {
+        clearBatches();
+        configureMemoryAdapter({});
+    });
+    it('uses specified provider', async () => {
+        const openAIBatch = createBatch({ provider: 'openai' });
+        const anthropicBatch = createBatch({ provider: 'anthropic' });
+        openAIBatch.add('Test prompt');
+        anthropicBatch.add('Test prompt');
+        const { job: oaiJob } = await openAIBatch.submit();
+        const { job: antJob } = await anthropicBatch.submit();
+        // Memory adapter simulates OpenAI for all providers
+        expect(oaiJob.provider).toBe('openai');
+        expect(antJob.provider).toBe('openai');
+    });
+    it('respects model configuration', async () => {
+        const customHandler = vi.fn().mockResolvedValue('Result');
+        configureMemoryAdapter({ handler: customHandler });
+        const batch = createBatch({ provider: 'openai', model: 'gpt-4o-mini' });
+        batch.add('Test prompt');
+        await batch.submit();
+        await batch.wait();
+        // The model should be passed to the handler via batch options
+        // (memory adapter doesn't use it, but real adapters would)
+        expect(customHandler).toHaveBeenCalled();
+    });
+});