@agents-at-scale/ark 0.1.40 → 0.1.42

package/dist/commands/models/providers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Provider configuration types and collectors.
+ *
+ * This module exports all provider-specific configurations and their collectors.
+ */
+export { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector, } from './types.js';
+export { OpenAIConfig, OpenAICollectorOptions, OpenAIConfigCollector, } from './openai.js';
+export { AzureConfig, AzureCollectorOptions, AzureConfigCollector, } from './azure.js';
+export { BedrockConfig, BedrockCollectorOptions, BedrockConfigCollector, } from './bedrock.js';
+export { ProviderConfigCollectorFactory } from './factory.js';
+import { OpenAIConfig } from './openai.js';
+import { AzureConfig } from './azure.js';
+import { BedrockConfig } from './bedrock.js';
+/**
+ * Union type of all supported provider configurations.
+ */
+export type ProviderConfig = OpenAIConfig | AzureConfig | BedrockConfig;

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

@@ -0,0 +1,9 @@
+/**
+ * Provider configuration types and collectors.
+ *
+ * This module exports all provider-specific configurations and their collectors.
+ */
+export { OpenAIConfigCollector, } from './openai.js';
+export { AzureConfigCollector, } from './azure.js';
+export { BedrockConfigCollector, } from './bedrock.js';
+export { ProviderConfigCollectorFactory } from './factory.js';

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

@@ -0,0 +1,28 @@
+import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } from './types.js';
+/**
+ * Configuration for OpenAI models.
+ */
+export interface OpenAIConfig extends BaseProviderConfig {
+    type: 'openai';
+    baseUrl: string;
+    apiKey: string;
+}
+/**
+ * Options specific to OpenAI collector.
+ */
+export interface OpenAICollectorOptions extends BaseCollectorOptions {
+    baseUrl?: string;
+    apiKey?: string;
+}
+/**
+ * Configuration collector for OpenAI models.
+ *
+ * Collects the necessary configuration to connect to an OpenAI-compatible API:
+ * - baseUrl: The API endpoint URL (e.g., https://api.openai.com/v1)
+ * - apiKey: The authentication key for the API
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export declare class OpenAIConfigCollector implements ProviderConfigCollector {
+    collectConfig(options: BaseCollectorOptions): Promise<OpenAIConfig>;
+}

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

@@ -0,0 +1,68 @@
+import inquirer from 'inquirer';
+/**
+ * Configuration collector for OpenAI models.
+ *
+ * Collects the necessary configuration to connect to an OpenAI-compatible API:
+ * - baseUrl: The API endpoint URL (e.g., https://api.openai.com/v1)
+ * - apiKey: The authentication key for the API
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export class OpenAIConfigCollector {
+    async collectConfig(options) {
+        const openaiOptions = options;
+        let baseUrl = openaiOptions.baseUrl;
+        if (!baseUrl) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'base URL:',
+                    validate: (input) => {
+                        if (!input)
+                            return 'base URL is required';
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'please enter a valid URL';
+                        }
+                    },
+                },
+            ]);
+            baseUrl = answer.baseUrl;
+        }
+        if (!baseUrl) {
+            throw new Error('base URL is required');
+        }
+        baseUrl = baseUrl.replace(/\/$/, '');
+        let apiKey = openaiOptions.apiKey;
+        if (!apiKey) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'apiKey',
+                    message: 'API key:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input)
+                            return 'API key is required';
+                        return true;
+                    },
+                },
+            ]);
+            apiKey = answer.apiKey;
+        }
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        return {
+            type: 'openai',
+            modelValue: options.model,
+            secretName: '',
+            baseUrl,
+            apiKey,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,180 @@
+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/models/providers/types.d.ts

@@ -0,0 +1,51 @@
+import type { ProviderConfig } from './index.js';
+/**
+ * Base configuration shared by all model providers.
+ */
+export interface BaseProviderConfig {
+    type: string;
+    modelValue: string;
+    secretName: string;
+}
+/**
+ * Common options available to all providers collectors.
+ *
+ * Can be extended with provider-specific options to grant more flexibility when configuring models on different providers.
+ *
+ * @field model - Model name (e.g., 'gpt-4o-mini')
+ * @field type - Model provider type (e.g., 'azure', 'openai', 'bedrock')
+ */
+export interface BaseCollectorOptions {
+    /**
+     * Model name (e.g., 'gpt-4o-mini')
+     */
+    model?: string;
+    /**
+     * Model provider type (e.g., 'azure', 'openai', 'bedrock')
+     */
+    type?: string;
+    [key: string]: unknown;
+}
+/**
+ * Provider configuration collector interface.
+ *
+ * A collector is responsible for gathering all the necessary configuration
+ * parameters for a specific model provider (OpenAI, Azure, Bedrock, etc.).
+ * It handles the interactive prompting of missing values and validation
+ * of user inputs, ensuring all required fields are collected before
+ * creating the model resource.
+ *
+ * The collector pattern allows each provider to define its own specific
+ * configuration requirements and prompts without affecting other providers.
+ */
+export interface ProviderConfigCollector {
+    /**
+     * Collects provider-specific configuration by prompting for any missing values.
+     *
+     * @param options - Options object that may contain pre-filled values.
+     *                  Each collector extracts only the fields it needs.
+     * @returns A promise that resolves to a complete provider configuration with all required fields
+     * @throws Error if a required field cannot be obtained or validation fails
+     */
+    collectConfig(options: BaseCollectorOptions): Promise<ProviderConfig>;
+}

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

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

package/dist/commands/queries/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createQueriesCommand(_: ArkConfig): Command;

package/dist/commands/queries/index.js

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { getResource } from '../../lib/kubectl.js';
+function renderMarkdown(content) {
+    if (process.stdout.isTTY) {
+        marked.setOptions({
+            // @ts-expect-error - TerminalRenderer types are incomplete
+            renderer: new TerminalRenderer({
+                showSectionPrefix: false,
+                reflowText: true,
+                // @ts-expect-error - preserveNewlines exists but not in types
+                preserveNewlines: true,
+            }),
+        });
+        return marked(content);
+    }
+    return content;
+}
+async function getQuery(name, options) {
+    try {
+        const query = await getResource('queries', name);
+        if (options.response) {
+            if (query.status?.responses && query.status.responses.length > 0) {
+                const response = query.status.responses[0];
+                if (options.output === 'markdown') {
+                    console.log(renderMarkdown(response.content || ''));
+                }
+                else {
+                    console.log(JSON.stringify(response, null, 2));
+                }
+            }
+            else {
+                output.warning('No response available');
+            }
+        }
+        else if (options.output === 'markdown') {
+            if (query.status?.responses && query.status.responses.length > 0) {
+                console.log(renderMarkdown(query.status.responses[0].content || ''));
+            }
+            else {
+                output.warning('No response available');
+            }
+        }
+        else {
+            console.log(JSON.stringify(query, null, 2));
+        }
+    }
+    catch (error) {
+        output.error('fetching query:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}
+export function createQueriesCommand(_) {
+    const queriesCommand = new Command('queries');
+    queriesCommand.description('Manage query resources');
+    const getCommand = new Command('get');
+    getCommand
+        .description('Get a specific query (@latest for most recent)')
+        .argument('<name>', 'Query name or @latest')
+        .option('-o, --output <format>', 'output format (json, markdown)', 'json')
+        .option('-r, --response', 'show only the response content', false)
+        .action(async (name, options) => {
+        await getQuery(name, options);
+    });
+    queriesCommand.addCommand(getCommand);
+    return queriesCommand;
+}

package/dist/commands/query/index.js

@@ -8,7 +8,8 @@ export function createQueryCommand(_) {
         .description('Execute a single query against a model or agent')
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
-        .action(async (target, message) => {
+        .option('-o, --output <format>', 'Output format: yaml, json, or name (prints only resource name)')
+        .action(async (target, message, options) => {
         const parsed = parseTarget(target);
         if (!parsed) {
             console.error(chalk.red('Invalid target format. Use: model/name or agent/name etc'));
@@ -18,6 +19,7 @@ export function createQueryCommand(_) {
             targetType: parsed.type,
             targetName: parsed.name,
             message,
+            outputFormat: options.output,
         });
     });
     return queryCommand;

package/dist/commands/query/index.spec.js

@@ -42,6 +42,30 @@ describe('createQueryCommand', () => {
             targetType: 'model',
             targetName: 'default',
             message: 'Hello world',
+            outputFormat: undefined,
+        });
+    });
+    it('should pass output format option to executeQuery', async () => {
+        mockParseTarget.mockReturnValue({
+            type: 'model',
+            name: 'default',
+        });
+        mockExecuteQuery.mockResolvedValue(undefined);
+        const command = createQueryCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'model/default',
+            'Hello world',
+            '-o',
+            'json',
+        ]);
+        expect(mockParseTarget).toHaveBeenCalledWith('model/default');
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'model',
+            targetName: 'default',
+            message: 'Hello world',
+            outputFormat: 'json',
         });
     });
     it('should error on invalid target format', async () => {