@agents-at-scale/ark 0.1.53 → 0.1.55

package/dist/commands/models/providers/azure.spec.js

@@ -1,232 +0,0 @@
-import { jest } from '@jest/globals';
-const mockInquirer = {
-    prompt: jest.fn(),
-};
-jest.unstable_mockModule('inquirer', () => ({
-    default: mockInquirer,
-}));
-const { AzureConfigCollector } = await import('./azure.js');
-describe('AzureConfigCollector', () => {
-    let collector;
-    beforeEach(() => {
-        collector = new AzureConfigCollector();
-        jest.clearAllMocks();
-    });
-    describe('collectConfig', () => {
-        it('uses provided options without prompting', async () => {
-            const options = {
-                model: 'gpt-4o-mini',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiKey: 'azure-key-12345',
-                apiVersion: '2024-12-01-preview',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).not.toHaveBeenCalled();
-            expect(config).toEqual({
-                type: 'azure',
-                modelValue: 'gpt-4o-mini',
-                secretName: '',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiKey: 'azure-key-12345',
-                apiVersion: '2024-12-01-preview',
-            });
-        });
-        it('uses default apiVersion when not provided', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiVersion: '2024-12-01-preview',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'azure-key' });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'apiVersion',
-                    message: 'Azure API version:',
-                    default: '2024-12-01-preview',
-                }),
-            ]);
-            expect(config.apiVersion).toBe('2024-12-01-preview');
-        });
-        it('prompts for missing baseUrl', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                baseUrl: 'https://contoso.openai.azure.com',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiVersion: '2024-10-01' });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'azure-key' });
-            const options = {
-                model: 'gpt-4',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'baseUrl',
-                    message: 'base URL:',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.baseUrl).toBe('https://contoso.openai.azure.com');
-        });
-        it('validates baseUrl is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ baseUrl: '' });
-            const options = {
-                model: 'gpt-4',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('base URL is required');
-        });
-        it('validates baseUrl is a valid URL', async () => {
-            const options = {
-                model: 'gpt-4',
-            };
-            // Get the validate function from the prompt call
-            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
-                const validate = questions[0].validate;
-                // Test invalid URL
-                expect(validate('not-a-url')).toBe('please enter a valid URL');
-                // Test empty string
-                expect(validate('')).toBe('base URL is required');
-                // Test valid URL
-                expect(validate('https://test.openai.azure.com')).toBe(true);
-                return { baseUrl: 'https://test.openai.azure.com' };
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiVersion: '2024-12-01-preview',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'azure-key' });
-            await collector.collectConfig(options);
-        });
-        it('removes trailing slash from baseUrl', async () => {
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com/',
-                apiKey: 'azure-key',
-                apiVersion: '2024-12-01-preview',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config.baseUrl).toBe('https://my-resource.openai.azure.com');
-        });
-        it('prompts for missing apiKey as password field', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiKey: 'azure-secret-key',
-            });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiVersion: '2024-12-01-preview',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'password',
-                    name: 'apiKey',
-                    message: 'API key:',
-                    mask: '*',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.apiKey).toBe('azure-secret-key');
-        });
-        it('validates apiKey is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: '' });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiVersion: '2024-12-01-preview',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('API key is required');
-        });
-        it('tests apiKey validation function', async () => {
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiVersion: '2024-12-01-preview',
-            };
-            // Get the validate function from the prompt call
-            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
-                const validate = questions[0].validate;
-                // Test empty string
-                expect(validate('')).toBe('API key is required');
-                // Test valid key
-                expect(validate('valid-azure-key')).toBe(true);
-                return { apiKey: 'valid-azure-key' };
-            });
-            await collector.collectConfig(options);
-        });
-        it('collects full configuration through interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                baseUrl: 'https://eastus.openai.azure.com/',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiVersion: '2024-08-01-preview',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiKey: 'abc123def456',
-            });
-            const options = {
-                model: 'gpt-4o',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'azure',
-                modelValue: 'gpt-4o',
-                secretName: '',
-                baseUrl: 'https://eastus.openai.azure.com',
-                apiKey: 'abc123def456',
-                apiVersion: '2024-08-01-preview',
-            });
-        });
-        it('mixes CLI options and interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiKey: 'prompted-key',
-            });
-            const options = {
-                model: 'gpt-35-turbo',
-                baseUrl: 'https://westeurope.openai.azure.com',
-                apiVersion: '2024-06-01',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'azure',
-                modelValue: 'gpt-35-turbo',
-                secretName: '',
-                baseUrl: 'https://westeurope.openai.azure.com',
-                apiKey: 'prompted-key',
-                apiVersion: '2024-06-01',
-            });
-        });
-        it('accepts custom apiVersion', async () => {
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-                apiKey: 'azure-key',
-                apiVersion: '2023-05-15',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config.apiVersion).toBe('2023-05-15');
-        });
-        it('prompts for apiVersion when only baseUrl is provided', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiVersion: '2024-12-01-preview',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'azure-key' });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://my-resource.openai.azure.com',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'apiVersion',
-                    message: 'Azure API version:',
-                    default: '2024-12-01-preview',
-                }),
-            ]);
-            expect(config.apiVersion).toBe('2024-12-01-preview');
-        });
-    });
-});

package/dist/commands/models/providers/bedrock.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/models/providers/bedrock.spec.js

@@ -1,241 +0,0 @@
-import { jest } from '@jest/globals';
-const mockInquirer = {
-    prompt: jest.fn(),
-};
-jest.unstable_mockModule('inquirer', () => ({
-    default: mockInquirer,
-}));
-const { BedrockConfigCollector } = await import('./bedrock.js');
-describe('BedrockConfigCollector', () => {
-    let collector;
-    beforeEach(() => {
-        collector = new BedrockConfigCollector();
-        jest.clearAllMocks();
-    });
-    describe('collectConfig', () => {
-        it('uses provided options without prompting', async () => {
-            const options = {
-                model: 'anthropic.claude-3-sonnet-20240229-v1:0',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-                sessionToken: 'session-token-123',
-                modelArn: 'arn:aws:bedrock:us-west-2:123456789012:model/test',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).not.toHaveBeenCalled();
-            expect(config).toEqual({
-                type: 'bedrock',
-                modelValue: 'anthropic.claude-3-sonnet-20240229-v1:0',
-                secretName: '',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-                sessionToken: 'session-token-123',
-                modelArn: 'arn:aws:bedrock:us-west-2:123456789012:model/test',
-            });
-        });
-        it('prompts for missing region with default', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ region: 'us-east-1' });
-            mockInquirer.prompt.mockResolvedValueOnce({ accessKeyId: 'AKIATEST' });
-            mockInquirer.prompt.mockResolvedValueOnce({ secretAccessKey: 'secret' });
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'region',
-                    message: 'AWS region:',
-                    default: 'us-east-1',
-                }),
-            ]);
-            expect(config.region).toBe('us-east-1');
-        });
-        it('throws error if region is missing after prompt', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ region: '' });
-            const options = {
-                model: 'test-model',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('region is required');
-        });
-        it('prompts for missing accessKeyId', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ secretAccessKey: 'secret' });
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'accessKeyId',
-                    message: 'AWS access key ID:',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.accessKeyId).toBe('AKIAIOSFODNN7EXAMPLE');
-        });
-        it('validates accessKeyId is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ accessKeyId: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('access key ID is required');
-        });
-        it('prompts for missing secretAccessKey as password field', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'password',
-                    name: 'secretAccessKey',
-                    message: 'AWS secret access key:',
-                    mask: '*',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.secretAccessKey).toBe('wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY');
-        });
-        it('validates secretAccessKey is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ secretAccessKey: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('secret access key is required');
-        });
-        it('prompts for optional sessionToken', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                sessionToken: 'optional-token',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'password',
-                    name: 'sessionToken',
-                    message: 'AWS session token (optional, press enter to skip):',
-                    mask: '*',
-                }),
-            ]);
-            expect(config.sessionToken).toBe('optional-token');
-        });
-        it('sets sessionToken to undefined when empty', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config.sessionToken).toBeUndefined();
-        });
-        it('prompts for optional modelArn', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                modelArn: 'arn:aws:bedrock:us-west-2:123456789012:model/test',
-            });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'modelArn',
-                    message: 'Model ARN (optional, press enter to skip):',
-                }),
-            ]);
-            expect(config.modelArn).toBe('arn:aws:bedrock:us-west-2:123456789012:model/test');
-        });
-        it('sets modelArn to undefined when empty', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'us-west-2',
-                accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
-                secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config.modelArn).toBeUndefined();
-        });
-        it('collects full configuration through interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ region: 'eu-west-1' });
-            mockInquirer.prompt.mockResolvedValueOnce({ accessKeyId: 'AKIATEST' });
-            mockInquirer.prompt.mockResolvedValueOnce({ secretAccessKey: 'secret123' });
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: 'token456' });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                modelArn: 'arn:aws:bedrock:eu-west-1:123:model/claude',
-            });
-            const options = {
-                model: 'anthropic.claude-v2',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'bedrock',
-                modelValue: 'anthropic.claude-v2',
-                secretName: '',
-                region: 'eu-west-1',
-                accessKeyId: 'AKIATEST',
-                secretAccessKey: 'secret123',
-                sessionToken: 'token456',
-                modelArn: 'arn:aws:bedrock:eu-west-1:123:model/claude',
-            });
-        });
-        it('mixes CLI options and interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                accessKeyId: 'AKIAPROMPTED',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ sessionToken: '' });
-            mockInquirer.prompt.mockResolvedValueOnce({ modelArn: '' });
-            const options = {
-                model: 'test-model',
-                region: 'ap-south-1',
-                secretAccessKey: 'providedSecret',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'bedrock',
-                modelValue: 'test-model',
-                secretName: '',
-                region: 'ap-south-1',
-                accessKeyId: 'AKIAPROMPTED',
-                secretAccessKey: 'providedSecret',
-                sessionToken: undefined,
-                modelArn: undefined,
-            });
-        });
-    });
-});

package/dist/commands/models/providers/openai.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/models/providers/openai.spec.js

@@ -1,180 +0,0 @@
-import { jest } from '@jest/globals';
-const mockInquirer = {
-    prompt: jest.fn(),
-};
-jest.unstable_mockModule('inquirer', () => ({
-    default: mockInquirer,
-}));
-const { OpenAIConfigCollector } = await import('./openai.js');
-describe('OpenAIConfigCollector', () => {
-    let collector;
-    beforeEach(() => {
-        collector = new OpenAIConfigCollector();
-        jest.clearAllMocks();
-    });
-    describe('collectConfig', () => {
-        it('uses provided options without prompting', async () => {
-            const options = {
-                model: 'gpt-4o-mini',
-                baseUrl: 'https://api.openai.com/v1',
-                apiKey: 'sk-test-key-12345',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).not.toHaveBeenCalled();
-            expect(config).toEqual({
-                type: 'openai',
-                modelValue: 'gpt-4o-mini',
-                secretName: '',
-                baseUrl: 'https://api.openai.com/v1',
-                apiKey: 'sk-test-key-12345',
-            });
-        });
-        it('prompts for missing baseUrl', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                baseUrl: 'https://custom-openai.com',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-custom-key' });
-            const options = {
-                model: 'gpt-4',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'input',
-                    name: 'baseUrl',
-                    message: 'base URL:',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.baseUrl).toBe('https://custom-openai.com');
-        });
-        it('validates baseUrl is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ baseUrl: '' });
-            const options = {
-                model: 'gpt-4',
-            };
-            // The validation happens in the prompt, but we test the final check
-            await expect(collector.collectConfig(options)).rejects.toThrow('base URL is required');
-        });
-        it('validates baseUrl is a valid URL', async () => {
-            const options = {
-                model: 'gpt-4',
-            };
-            // Get the validate function from the prompt call
-            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
-                const validate = questions[0].validate;
-                // Test invalid URL
-                expect(validate('not-a-url')).toBe('please enter a valid URL');
-                // Test empty string
-                expect(validate('')).toBe('base URL is required');
-                // Test valid URL
-                expect(validate('https://api.openai.com')).toBe(true);
-                return { baseUrl: 'https://api.openai.com' };
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-key' });
-            await collector.collectConfig(options);
-        });
-        it('removes trailing slash from baseUrl', async () => {
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://api.openai.com/v1/',
-                apiKey: 'sk-test-key',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config.baseUrl).toBe('https://api.openai.com/v1');
-        });
-        it('prompts for missing apiKey as password field', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-secret-key' });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://api.openai.com/v1',
-            };
-            const config = await collector.collectConfig(options);
-            expect(mockInquirer.prompt).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    type: 'password',
-                    name: 'apiKey',
-                    message: 'API key:',
-                    mask: '*',
-                    validate: expect.any(Function),
-                }),
-            ]);
-            expect(config.apiKey).toBe('sk-secret-key');
-        });
-        it('validates apiKey is required', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: '' });
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://api.openai.com/v1',
-            };
-            await expect(collector.collectConfig(options)).rejects.toThrow('API key is required');
-        });
-        it('tests apiKey validation function', async () => {
-            const options = {
-                model: 'gpt-4',
-                baseUrl: 'https://api.openai.com/v1',
-            };
-            // Get the validate function from the prompt call
-            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
-                const validate = questions[0].validate;
-                // Test empty string
-                expect(validate('')).toBe('API key is required');
-                // Test valid key
-                expect(validate('sk-valid-key')).toBe(true);
-                return { apiKey: 'sk-valid-key' };
-            });
-            await collector.collectConfig(options);
-        });
-        it('collects full configuration through interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                baseUrl: 'https://api.openai.com/v1/',
-            });
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiKey: 'sk-proj-abc123',
-            });
-            const options = {
-                model: 'gpt-4o',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'openai',
-                modelValue: 'gpt-4o',
-                secretName: '',
-                baseUrl: 'https://api.openai.com/v1',
-                apiKey: 'sk-proj-abc123',
-            });
-        });
-        it('mixes CLI options and interactive prompts', async () => {
-            mockInquirer.prompt.mockResolvedValueOnce({
-                apiKey: 'sk-prompted-key',
-            });
-            const options = {
-                model: 'gpt-3.5-turbo',
-                baseUrl: 'https://custom-api.com/v1',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'openai',
-                modelValue: 'gpt-3.5-turbo',
-                secretName: '',
-                baseUrl: 'https://custom-api.com/v1',
-                apiKey: 'sk-prompted-key',
-            });
-        });
-        it('handles custom OpenAI-compatible endpoints', async () => {
-            const options = {
-                model: 'llama-3-8b',
-                baseUrl: 'https://localhost:8080/v1',
-                apiKey: 'local-key-123',
-            };
-            const config = await collector.collectConfig(options);
-            expect(config).toEqual({
-                type: 'openai',
-                modelValue: 'llama-3-8b',
-                secretName: '',
-                baseUrl: 'https://localhost:8080/v1',
-                apiKey: 'local-key-123',
-            });
-        });
-    });
-});

package/dist/commands/queries/delete.spec.d.ts

@@ -1 +0,0 @@
-export {};