overai 1.4.0

package/dist/cli/commands/observability.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Observability command - Monitoring and tracing
+ *
+ * Supports 14+ observability integrations:
+ * - list: List all available observability tools
+ * - doctor: Check environment variables for selected tool
+ * - test: Run a test trace to verify tool works
+ * - info: Show observability feature information
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+const types_1 = require("../../observability/types");
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'list':
+            case 'providers':
+                await listProvidersCommand(options, outputFormat);
+                break;
+            case 'doctor':
+                await doctorCommand(args[1] || options.tool, options, outputFormat);
+                break;
+            case 'test':
+                await testCommand(args[1] || options.tool, options, outputFormat);
+                break;
+            case 'info':
+                await showInfo(outputFormat);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function showInfo(outputFormat) {
+    const info = {
+        feature: 'Observability',
+        description: 'Monitoring, tracing, and logging for agent operations',
+        providers: [
+            { name: 'ConsoleObservabilityProvider', description: 'Console-based logging' },
+            { name: 'MemoryObservabilityProvider', description: 'In-memory trace storage' },
+            { name: 'LangfuseObservabilityProvider', description: 'Langfuse integration' }
+        ],
+        capabilities: [
+            'Trace agent executions',
+            'Log LLM calls and responses',
+            'Track tool invocations',
+            'Measure performance metrics',
+            'Export traces to external systems'
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(info));
+    }
+    else {
+        await pretty.heading('Observability');
+        await pretty.plain(info.description);
+        await pretty.newline();
+        await pretty.plain('Providers:');
+        for (const p of info.providers) {
+            await pretty.plain(`  • ${p.name}: ${p.description}`);
+        }
+        await pretty.newline();
+        await pretty.plain('Capabilities:');
+        for (const cap of info.capabilities) {
+            await pretty.plain(`  • ${cap}`);
+        }
+    }
+}
+/**
+ * List all observability tools
+ */
+async function listProvidersCommand(options, outputFormat) {
+    const tools = (0, types_1.listObservabilityTools)();
+    const providers = tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        package: tool.package,
+        envKey: tool.envKey,
+        hasEnvKey: (0, types_1.hasObservabilityToolEnvVar)(tool.name),
+        features: tool.features
+    }));
+    const ready = providers.filter(p => p.hasEnvKey);
+    const builtIn = providers.filter(p => ['console', 'memory', 'noop'].includes(p.name));
+    const external = providers.filter(p => !['console', 'memory', 'noop'].includes(p.name));
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            providers,
+            total: providers.length,
+            ready: ready.length,
+            builtin: builtIn.length,
+            external: external.length
+        }));
+    }
+    else {
+        await pretty.heading('Observability Tools');
+        await pretty.plain(`\n  Total: ${providers.length} tools (${ready.length} ready)`);
+        await pretty.plain('\n  Built-in (no setup required):');
+        for (const p of builtIn) {
+            await pretty.plain(`    ✅ ${p.name.padEnd(12)} ${p.description}`);
+        }
+        await pretty.plain('\n  External Integrations:');
+        for (const p of external) {
+            const status = p.hasEnvKey ? '✅' : '⚠️';
+            const keyInfo = p.envKey ? ` (${p.envKey})` : '';
+            await pretty.plain(`    ${status} ${p.name.padEnd(12)} ${p.description}${options.verbose ? keyInfo : ''}`);
+        }
+        await pretty.newline();
+        await pretty.info('Run "observability doctor <tool>" for setup instructions');
+    }
+}
+/**
+ * Doctor command - Check environment for a tool
+ */
+async function doctorCommand(toolName, options, outputFormat) {
+    if (!toolName) {
+        // Check all tools
+        const tools = (0, types_1.listObservabilityTools)();
+        const results = tools.map(tool => ({
+            name: tool.name,
+            envKey: tool.envKey,
+            hasKey: (0, types_1.hasObservabilityToolEnvVar)(tool.name),
+            package: tool.package
+        }));
+        const ready = results.filter(r => r.hasKey);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                total: results.length,
+                ready: ready.length,
+                tools: results
+            }));
+        }
+        else {
+            await pretty.heading('Observability Environment Check');
+            await pretty.plain(`\n  Total Tools: ${results.length}`);
+            await pretty.plain(`  Ready: ${ready.length} ✅`);
+            if (ready.length > 0) {
+                await pretty.plain('\n  Ready Tools:');
+                for (const t of ready) {
+                    await pretty.plain(`    ✅ ${t.name}`);
+                }
+            }
+            await pretty.newline();
+            await pretty.info('Run "observability doctor <tool>" for specific tool setup');
+        }
+        return;
+    }
+    // Check specific tool
+    const tool = types_1.OBSERVABILITY_TOOLS[toolName.toLowerCase()];
+    if (!tool) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.INVALID_ARGS, `Unknown tool: ${toolName}`));
+        }
+        else {
+            await pretty.error(`Unknown tool: ${toolName}`);
+            await pretty.info(`Available: ${Object.keys(types_1.OBSERVABILITY_TOOLS).join(', ')}`);
+        }
+        return;
+    }
+    const hasKey = (0, types_1.hasObservabilityToolEnvVar)(tool.name);
+    const keyValue = tool.envKey ? process.env[tool.envKey] : null;
+    const maskedKey = keyValue ? `${keyValue.slice(0, 4)}...${keyValue.slice(-4)}` : 'not set';
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            tool: tool.name,
+            env_key: tool.envKey,
+            has_key: hasKey,
+            key_preview: hasKey ? maskedKey : null,
+            package: tool.package,
+            description: tool.description,
+            features: tool.features,
+            status: hasKey || !tool.envKey ? 'ready' : 'missing_key'
+        }));
+    }
+    else {
+        await pretty.heading(`Observability Doctor: ${tool.name}`);
+        await pretty.plain(`  Description: ${tool.description}`);
+        if (tool.package) {
+            await pretty.plain(`  Package: ${tool.package}`);
+        }
+        if (tool.envKey) {
+            await pretty.plain(`  Environment Variable: ${tool.envKey}`);
+            await pretty.plain(`  Status: ${hasKey ? '✅ Ready' : '❌ Missing API Key'}`);
+            if (hasKey) {
+                await pretty.dim(`  Key Preview: ${maskedKey}`);
+            }
+            else {
+                await pretty.newline();
+                await pretty.info(`Set the API key with:`);
+                await pretty.dim(`  export ${tool.envKey}=your-api-key`);
+            }
+        }
+        else {
+            await pretty.plain(`  Status: ✅ Ready (no API key required)`);
+        }
+        await pretty.newline();
+        await pretty.plain('  Features:');
+        const f = tool.features;
+        await pretty.plain(`    Traces: ${f.traces ? '✅' : '❌'}  Spans: ${f.spans ? '✅' : '❌'}  Events: ${f.events ? '✅' : '❌'}`);
+        await pretty.plain(`    Errors: ${f.errors ? '✅' : '❌'}  Metrics: ${f.metrics ? '✅' : '❌'}  Export: ${f.export ? '✅' : '❌'}`);
+    }
+}
+/**
+ * Test command - Run a test trace
+ */
+async function testCommand(toolName, options, outputFormat) {
+    const tool = toolName?.toLowerCase() || 'memory';
+    if (!types_1.OBSERVABILITY_TOOLS[tool]) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.INVALID_ARGS, `Unknown tool: ${toolName}`));
+        }
+        else {
+            await pretty.error(`Unknown tool: ${toolName}`);
+        }
+        return;
+    }
+    if (outputFormat !== 'json') {
+        await pretty.info(`Testing ${tool} observability...`);
+    }
+    const startTime = Date.now();
+    try {
+        const { createObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('../../observability/adapters')));
+        const adapter = await createObservabilityAdapter(tool);
+        // Run a test trace
+        const trace = adapter.startTrace('test-trace', { test: true });
+        const span = adapter.startSpan(trace.traceId, 'test-span', 'custom');
+        adapter.addEvent(span.spanId, 'test-event', { message: 'hello' });
+        adapter.endSpan(span.spanId, 'completed');
+        adapter.endTrace(trace.traceId, 'completed');
+        await adapter.flush();
+        const latency = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                tool,
+                status: 'success',
+                latency_ms: latency,
+                trace_id: trace.traceId
+            }));
+        }
+        else {
+            await pretty.plain(`\n  ✅ Test Passed`);
+            await pretty.plain(`  Tool: ${tool}`);
+            await pretty.plain(`  Latency: ${latency}ms`);
+            await pretty.dim(`  Trace ID: ${trace.traceId}`);
+        }
+    }
+    catch (error) {
+        const latency = Date.now() - startTime;
+        const errorMessage = error.message || String(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, errorMessage, {
+                tool,
+                latency_ms: latency
+            }));
+        }
+        else {
+            await pretty.error(`Test Failed: ${errorMessage}`);
+            await pretty.plain(`  Tool: ${tool}`);
+            await pretty.plain(`  Latency: ${latency}ms`);
+        }
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'observability',
+        description: 'Monitoring and tracing for agent operations',
+        subcommands: [
+            { name: 'info', description: 'Show observability feature information' },
+            { name: 'providers', description: 'List available observability providers' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Observability Command');
+        await pretty.plain(help.description);
+        await pretty.newline();
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
+        }
+    }
+}

package/dist/cli/commands/planning.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Planning command - Task planning and todo management
+ */
+export interface PlanningOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+export declare function execute(args: string[], options: PlanningOptions): Promise<void>;

package/dist/cli/commands/planning.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Planning command - Task planning and todo management
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const planning_1 = require("../../planning");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+async function execute(args, options) {
+    const action = args[0] || 'help';
+    const actionArgs = args.slice(1);
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        switch (action) {
+            case 'create':
+                await createNewPlan(actionArgs, outputFormat);
+                break;
+            case 'todo':
+                await manageTodo(actionArgs, outputFormat);
+                break;
+            case 'help':
+            default:
+                await showHelp(outputFormat);
+                break;
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}
+async function createNewPlan(args, outputFormat) {
+    const name = args.join(' ');
+    if (!name) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a name for the plan'));
+        }
+        else {
+            await pretty.error('Please provide a name for the plan');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const plan = (0, planning_1.createPlan)({
+        name,
+        description: name
+    });
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)({
+            id: plan.id,
+            name: plan.name,
+            status: plan.status
+        }));
+    }
+    else {
+        await pretty.success(`Plan created: ${plan.id}`);
+        await pretty.plain(`Name: ${name}`);
+    }
+}
+async function manageTodo(args, outputFormat) {
+    const subAction = args[0] || 'list';
+    const todoArgs = args.slice(1);
+    const todoList = (0, planning_1.createTodoList)();
+    switch (subAction) {
+        case 'add':
+            const content = todoArgs.join(' ');
+            if (!content) {
+                if (outputFormat === 'json') {
+                    (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide todo content'));
+                }
+                else {
+                    await pretty.error('Please provide todo content');
+                }
+                process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+            }
+            const newItem = new planning_1.TodoItem({ content });
+            todoList.add(newItem);
+            if (outputFormat === 'json') {
+                (0, json_1.outputJson)((0, json_1.formatSuccess)({ added: true, id: newItem.id, content: newItem.content }));
+            }
+            else {
+                await pretty.success(`Todo added: ${content}`);
+            }
+            break;
+        case 'list':
+        default:
+            const items = todoList.items;
+            if (outputFormat === 'json') {
+                (0, json_1.outputJson)((0, json_1.formatSuccess)({ items, count: items.length }));
+            }
+            else {
+                await pretty.heading('Todo List');
+                if (items.length === 0) {
+                    await pretty.info('No todos');
+                }
+                else {
+                    for (const todo of items) {
+                        const status = todo.status === 'completed' ? '✓' : '○';
+                        await pretty.plain(`  ${status} ${todo.content}`);
+                    }
+                }
+            }
+            break;
+    }
+}
+async function showHelp(outputFormat) {
+    const help = {
+        command: 'planning',
+        subcommands: [
+            { name: 'create <goal>', description: 'Create a new plan' },
+            { name: 'todo add <title>', description: 'Add a todo item' },
+            { name: 'todo list', description: 'List todo items' },
+            { name: 'help', description: 'Show this help' }
+        ]
+    };
+    if (outputFormat === 'json') {
+        (0, json_1.outputJson)((0, json_1.formatSuccess)(help));
+    }
+    else {
+        await pretty.heading('Planning Command');
+        await pretty.plain('Task planning and todo management\n');
+        await pretty.plain('Subcommands:');
+        for (const cmd of help.subcommands) {
+            await pretty.plain(`  ${cmd.name.padEnd(25)} ${cmd.description}`);
+        }
+    }
+}

package/dist/cli/commands/prompt-expand.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prompt Expand command - Expand prompts with more detail
+ */
+export interface PromptExpandOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    strategy?: string;
+}
+export declare function execute(args: string[], options: PromptExpandOptions): Promise<void>;

package/dist/cli/commands/prompt-expand.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Prompt Expand command - Expand prompts with more detail
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const prompt_expander_1 = require("../../agent/prompt-expander");
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+async function execute(args, options) {
+    const prompt = args.join(' ');
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    const config = (0, resolve_1.resolveConfig)(options);
+    if (!prompt) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a prompt to expand'));
+        }
+        else {
+            await pretty.error('Please provide a prompt to expand');
+            await pretty.dim('Usage: praisonai-ts prompt-expand "your prompt"');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    try {
+        if (outputFormat !== 'json') {
+            await pretty.info(`Expanding prompt: "${prompt}"`);
+        }
+        const agent = (0, prompt_expander_1.createPromptExpanderAgent)({
+            llm: config.model,
+            verbose: options.verbose,
+            defaultStrategy: options.strategy
+        });
+        const result = await agent.expand(prompt);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                originalPrompt: prompt,
+                expandedPrompt: result.expanded,
+                strategy: result.strategy,
+                additions: result.additions
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            await pretty.heading('Expanded Prompt');
+            await pretty.plain(result.expanded);
+            await pretty.newline();
+            await pretty.dim(`Strategy: ${result.strategy}`);
+            await pretty.success(`Completed in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}

package/dist/cli/commands/providers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Providers command - List and manage LLM providers
+ *
+ * Supports:
+ * - list: List all registered providers (60+ AI SDK v6 providers)
+ * - doctor: Check environment variables for selected provider
+ * - test: Run a small test request to verify provider works
+ * - info: Show provider details
+ */
+export interface ProvidersOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    provider?: string;
+    model?: string;
+}
+export declare function execute(args: string[], options: ProvidersOptions): Promise<void>;