@agents-at-scale/ark 0.1.40 → 0.1.42

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

@@ -0,0 +1,230 @@
+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.d.ts

@@ -0,0 +1,37 @@
+import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } from './types.js';
+/**
+ * Configuration for AWS Bedrock models.
+ */
+export interface BedrockConfig extends BaseProviderConfig {
+    type: 'bedrock';
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    modelArn?: string;
+}
+/**
+ * Options specific to Bedrock collector.
+ */
+export interface BedrockCollectorOptions extends BaseCollectorOptions {
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    modelArn?: string;
+}
+/**
+ * Configuration collector for AWS Bedrock models.
+ *
+ * Collects the necessary configuration to connect to AWS Bedrock:
+ * - region: The AWS region where Bedrock is deployed (e.g., us-east-1)
+ * - accessKeyId: AWS access key ID for authentication
+ * - secretAccessKey: AWS secret access key for authentication
+ * - sessionToken: (Optional) AWS session token for temporary credentials
+ * - modelArn: (Optional) Specific ARN for the model to use
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export declare class BedrockConfigCollector implements ProviderConfigCollector {
+    collectConfig(options: BaseCollectorOptions): Promise<BedrockConfig>;
+}

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

@@ -0,0 +1,105 @@
+import inquirer from 'inquirer';
+/**
+ * Configuration collector for AWS Bedrock models.
+ *
+ * Collects the necessary configuration to connect to AWS Bedrock:
+ * - region: The AWS region where Bedrock is deployed (e.g., us-east-1)
+ * - accessKeyId: AWS access key ID for authentication
+ * - secretAccessKey: AWS secret access key for authentication
+ * - sessionToken: (Optional) AWS session token for temporary credentials
+ * - modelArn: (Optional) Specific ARN for the model to use
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export class BedrockConfigCollector {
+    async collectConfig(options) {
+        const bedrockOptions = options;
+        let region = bedrockOptions.region;
+        if (!region) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'region',
+                    message: 'AWS region:',
+                    default: 'us-east-1',
+                },
+            ]);
+            region = answer.region;
+        }
+        if (!region) {
+            throw new Error('region is required');
+        }
+        let accessKeyId = bedrockOptions.accessKeyId;
+        if (!accessKeyId) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'accessKeyId',
+                    message: 'AWS access key ID:',
+                    validate: (input) => {
+                        if (!input)
+                            return 'access key ID is required';
+                        return true;
+                    },
+                },
+            ]);
+            accessKeyId = answer.accessKeyId;
+        }
+        if (!accessKeyId) {
+            throw new Error('access key ID is required');
+        }
+        let secretAccessKey = bedrockOptions.secretAccessKey;
+        if (!secretAccessKey) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'secretAccessKey',
+                    message: 'AWS secret access key:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input)
+                            return 'secret access key is required';
+                        return true;
+                    },
+                },
+            ]);
+            secretAccessKey = answer.secretAccessKey;
+        }
+        if (!secretAccessKey) {
+            throw new Error('secret access key is required');
+        }
+        let sessionToken = bedrockOptions.sessionToken;
+        if (!sessionToken) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'sessionToken',
+                    message: 'AWS session token (optional, press enter to skip):',
+                    mask: '*',
+                },
+            ]);
+            sessionToken = answer.sessionToken;
+        }
+        let modelArn = bedrockOptions.modelArn;
+        if (!modelArn) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'modelArn',
+                    message: 'Model ARN (optional, press enter to skip):',
+                },
+            ]);
+            modelArn = answer.modelArn;
+        }
+        return {
+            type: 'bedrock',
+            modelValue: options.model,
+            secretName: '',
+            region,
+            accessKeyId,
+            secretAccessKey,
+            sessionToken: sessionToken || undefined,
+            modelArn: modelArn || undefined,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,241 @@
+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/factory.d.ts

@@ -0,0 +1,18 @@
+import { ProviderConfigCollector } from './types.js';
+/**
+ * Factory for creating provider-specific configuration collectors.
+ *
+ * This factory uses the provider type to instantiate the appropriate collector
+ * that knows how to gather configuration for that specific provider.
+ * This pattern makes it easy to add new providers without modifying existing code.
+ */
+export declare class ProviderConfigCollectorFactory {
+    /**
+     * Creates a configuration collector for the specified provider type.
+     *
+     * @param type - The provider type ('openai', 'azure', or 'bedrock')
+     * @returns A collector instance for the specified provider
+     * @throws Error if the provider type is not recognized
+     */
+    static create(type: string): ProviderConfigCollector;
+}

package/dist/commands/models/providers/factory.js

@@ -0,0 +1,31 @@
+import { OpenAIConfigCollector } from './openai.js';
+import { AzureConfigCollector } from './azure.js';
+import { BedrockConfigCollector } from './bedrock.js';
+/**
+ * Factory for creating provider-specific configuration collectors.
+ *
+ * This factory uses the provider type to instantiate the appropriate collector
+ * that knows how to gather configuration for that specific provider.
+ * This pattern makes it easy to add new providers without modifying existing code.
+ */
+export class ProviderConfigCollectorFactory {
+    /**
+     * Creates a configuration collector for the specified provider type.
+     *
+     * @param type - The provider type ('openai', 'azure', or 'bedrock')
+     * @returns A collector instance for the specified provider
+     * @throws Error if the provider type is not recognized
+     */
+    static create(type) {
+        switch (type) {
+            case 'openai':
+                return new OpenAIConfigCollector();
+            case 'azure':
+                return new AzureConfigCollector();
+            case 'bedrock':
+                return new BedrockConfigCollector();
+            default:
+                throw new Error(`Unknown provider type: ${type}`);
+        }
+    }
+}