overai 1.4.0

package/dist/cli/commands/llm.js

@@ -0,0 +1,748 @@
+"use strict";
+/**
+ * LLM Command - AI SDK provider management and testing
+ *
+ * Subcommands:
+ * - providers: List available AI SDK providers
+ * - test: Test connectivity to a provider
+ * - validate: Validate provider configuration
+ * - run: Run a prompt with a specific model
+ */
+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 pretty_logger_1 = require("../../utils/pretty-logger");
+function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function formatSuccess(data) {
+    return { success: true, data };
+}
+function formatError(code, message) {
+    return { success: false, error: { code, message } };
+}
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGS',
+    MISSING_ARG: 'MISSING_ARG',
+};
+// Exit codes specific to LLM commands
+const LLM_EXIT_CODES = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    INVALID_ARGS: 2,
+    AUTH_ERROR: 3,
+    PROVIDER_NOT_FOUND: 4,
+    NETWORK_ERROR: 5,
+    TIMEOUT: 6,
+};
+async function execute(args, options) {
+    const subcommand = args[0] || 'providers';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    switch (subcommand) {
+        case 'providers':
+            await providersCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'test':
+            await testCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'validate':
+            await validateCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'run':
+            await runCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'models':
+            await modelsCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'config':
+            await configCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'trace':
+            await traceCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'tools':
+            await toolsCommand(args.slice(1), options, outputFormat);
+            break;
+        case 'json':
+            await jsonCommand(args.slice(1), options, outputFormat);
+            break;
+        default:
+            if (outputFormat === 'json') {
+                outputJson(formatError(ERROR_CODES.INVALID_ARGS, `Unknown subcommand: ${subcommand}`));
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.error(`Unknown subcommand: ${subcommand}`);
+                await pretty_logger_1.PrettyLogger.info('Available subcommands: providers, test, validate, run, models, config, trace, tools, json');
+            }
+            process.exit(LLM_EXIT_CODES.INVALID_ARGS);
+    }
+}
+/**
+ * List available AI SDK providers
+ */
+async function providersCommand(args, options, outputFormat) {
+    try {
+        const { listSupportedProviders, AISDK_PROVIDERS, validateProviderApiKey, isAISDKAvailable, getAISDKVersion } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        const providers = listSupportedProviders();
+        const aiSdkAvailable = await isAISDKAvailable();
+        const aiSdkVersion = await getAISDKVersion();
+        const providerDetails = providers.map((id) => {
+            const info = AISDK_PROVIDERS[id];
+            const hasApiKey = validateProviderApiKey(id);
+            return {
+                id,
+                package: info?.package || 'custom',
+                envKey: info?.envKey || 'N/A',
+                hasApiKey,
+                status: hasApiKey ? 'ready' : 'missing_key'
+            };
+        });
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                ai_sdk_available: aiSdkAvailable,
+                ai_sdk_version: aiSdkVersion,
+                providers: providerDetails,
+                total: providers.length
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading('AI SDK Providers');
+            if (aiSdkAvailable) {
+                await pretty_logger_1.PrettyLogger.success(`AI SDK: ${aiSdkVersion || 'installed'}`);
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.warning('AI SDK not installed. Run: npm install ai');
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Available Providers:');
+            for (const p of providerDetails) {
+                const status = p.hasApiKey ? '✅' : '⚠️';
+                const keyInfo = p.hasApiKey ? '🔑' : `Missing ${p.envKey}`;
+                await pretty_logger_1.PrettyLogger.plain(`    ${status} ${p.id.padEnd(20)} ${keyInfo}`);
+                if (options.verbose) {
+                    await pretty_logger_1.PrettyLogger.dim(`        Package: ${p.package}`);
+                }
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('Set API keys via environment variables');
+            await pretty_logger_1.PrettyLogger.dim('  Example: export OPENAI_API_KEY=sk-...');
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to list providers');
+    }
+}
+/**
+ * Test connectivity to a provider
+ */
+async function testCommand(args, options, outputFormat) {
+    const providerId = args[0] || options.provider;
+    if (!providerId) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Provider ID required'));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error('Provider ID required. Usage: llm test <provider>');
+            await pretty_logger_1.PrettyLogger.dim('  Example: praisonai-ts llm test openai');
+        }
+        process.exit(LLM_EXIT_CODES.INVALID_ARGS);
+        return;
+    }
+    try {
+        const { createAISDKBackend, validateProviderApiKey, getMissingApiKeyMessage, isProviderSupported } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        // Check if provider is supported
+        if (!isProviderSupported(providerId)) {
+            if (outputFormat === 'json') {
+                outputJson(formatError('PROVIDER_NOT_FOUND', `Provider '${providerId}' is not supported`));
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.error(`Provider '${providerId}' is not supported`);
+            }
+            process.exit(LLM_EXIT_CODES.PROVIDER_NOT_FOUND);
+            return;
+        }
+        // Check API key
+        if (!validateProviderApiKey(providerId)) {
+            const msg = getMissingApiKeyMessage(providerId);
+            if (outputFormat === 'json') {
+                outputJson(formatError('AUTH_ERROR', msg));
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.error(msg);
+            }
+            process.exit(LLM_EXIT_CODES.AUTH_ERROR);
+            return;
+        }
+        // Determine test model based on provider
+        const testModels = {
+            openai: 'gpt-4o-mini',
+            anthropic: 'claude-3-haiku-20240307',
+            google: 'gemini-1.5-flash',
+            groq: 'llama-3.1-8b-instant',
+            mistral: 'mistral-small-latest',
+            cohere: 'command-light',
+            deepseek: 'deepseek-chat',
+        };
+        const modelId = options.model || testModels[providerId] || 'default';
+        const modelString = `${providerId}/${modelId}`;
+        if (outputFormat !== 'json') {
+            await pretty_logger_1.PrettyLogger.info(`Testing ${modelString}...`);
+        }
+        const startTime = Date.now();
+        const backend = createAISDKBackend(modelString, {
+            timeout: options.timeout || 30000,
+            maxRetries: 0, // No retries for test
+        });
+        const result = await backend.generateText({
+            messages: [
+                { role: 'user', content: 'Say "OK" and nothing else.' }
+            ],
+            maxTokens: 10,
+            temperature: 0,
+        });
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                provider: providerId,
+                model: modelId,
+                status: 'success',
+                duration_ms: duration,
+                response: result.text,
+                usage: result.usage
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.success(`Connection successful! (${duration}ms)`);
+            await pretty_logger_1.PrettyLogger.plain(`  Provider: ${providerId}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Model: ${modelId}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Response: ${result.text.trim()}`);
+            if (result.usage) {
+                await pretty_logger_1.PrettyLogger.dim(`  Tokens: ${result.usage.totalTokens}`);
+            }
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, `Failed to test provider '${providerId}'`);
+    }
+}
+/**
+ * Validate provider configuration
+ */
+async function validateCommand(args, options, outputFormat) {
+    const providerId = args[0] || options.provider;
+    if (!providerId) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Provider ID required'));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error('Provider ID required. Usage: llm validate --provider <id>');
+        }
+        process.exit(LLM_EXIT_CODES.INVALID_ARGS);
+        return;
+    }
+    try {
+        const { isProviderSupported, validateProviderApiKey, getProviderEnvKey, getProviderPackage, isAISDKAvailable } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        const checks = [];
+        // Check AI SDK availability
+        const aiSdkAvailable = await isAISDKAvailable();
+        checks.push({
+            name: 'AI SDK Installed',
+            passed: aiSdkAvailable,
+            message: aiSdkAvailable ? 'AI SDK is installed' : 'AI SDK not found. Run: npm install ai'
+        });
+        // Check provider support
+        const isSupported = isProviderSupported(providerId);
+        checks.push({
+            name: 'Provider Supported',
+            passed: isSupported,
+            message: isSupported ? `Provider '${providerId}' is supported` : `Provider '${providerId}' is not supported`
+        });
+        if (isSupported) {
+            // Check provider package
+            const pkg = getProviderPackage(providerId);
+            if (pkg) {
+                let pkgInstalled = false;
+                try {
+                    require.resolve(pkg);
+                    pkgInstalled = true;
+                }
+                catch {
+                    pkgInstalled = false;
+                }
+                checks.push({
+                    name: 'Provider Package',
+                    passed: pkgInstalled,
+                    message: pkgInstalled ? `${pkg} is installed` : `${pkg} not found. Run: npm install ${pkg}`
+                });
+            }
+            // Check API key
+            const hasApiKey = validateProviderApiKey(providerId);
+            const envKey = getProviderEnvKey(providerId);
+            checks.push({
+                name: 'API Key',
+                passed: hasApiKey,
+                message: hasApiKey
+                    ? `${envKey} is set`
+                    : `${envKey} is not set`
+            });
+        }
+        const allPassed = checks.every(c => c.passed);
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                provider: providerId,
+                valid: allPassed,
+                checks
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading(`Validation: ${providerId}`);
+            for (const check of checks) {
+                const icon = check.passed ? '✅' : '❌';
+                await pretty_logger_1.PrettyLogger.plain(`  ${icon} ${check.name}: ${check.message}`);
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            if (allPassed) {
+                await pretty_logger_1.PrettyLogger.success('All checks passed!');
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.warning('Some checks failed. Fix the issues above.');
+                process.exit(LLM_EXIT_CODES.GENERAL_ERROR);
+            }
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, `Failed to validate provider '${providerId}'`);
+    }
+}
+/**
+ * Run a prompt with a specific model
+ */
+async function runCommand(args, options, outputFormat) {
+    const prompt = args.join(' ');
+    if (!prompt) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Prompt required'));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error('Prompt required. Usage: llm run "<prompt>" --model <provider/model>');
+            await pretty_logger_1.PrettyLogger.dim('  Example: overai llm run "Hello!" --model openai/gpt-4o-mini');
+        }
+        process.exit(LLM_EXIT_CODES.INVALID_ARGS);
+        return;
+    }
+    const modelString = options.model || 'openai/gpt-4o-mini';
+    try {
+        const { createAISDKBackend } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        const backend = createAISDKBackend(modelString, {
+            timeout: options.timeout || 60000,
+        });
+        if (options.stream) {
+            // Streaming mode
+            if (outputFormat === 'json') {
+                // JSON streaming - output each chunk as JSON line
+                const stream = await backend.streamText({
+                    messages: [{ role: 'user', content: prompt }],
+                });
+                process.stdout.write('{"type":"stream_start"}\n');
+                let fullText = '';
+                for await (const chunk of stream) {
+                    if (chunk.text) {
+                        fullText += chunk.text;
+                        process.stdout.write(JSON.stringify({ type: 'text', text: chunk.text }) + '\n');
+                    }
+                    if (chunk.finishReason) {
+                        process.stdout.write(JSON.stringify({
+                            type: 'finish',
+                            finishReason: chunk.finishReason,
+                            usage: chunk.usage
+                        }) + '\n');
+                    }
+                }
+                process.stdout.write(JSON.stringify({ type: 'stream_end', fullText }) + '\n');
+            }
+            else {
+                // Pretty streaming - output text directly
+                const stream = await backend.streamText({
+                    messages: [{ role: 'user', content: prompt }],
+                });
+                for await (const chunk of stream) {
+                    if (chunk.text) {
+                        process.stdout.write(chunk.text);
+                    }
+                }
+                process.stdout.write('\n');
+            }
+        }
+        else {
+            // Non-streaming mode
+            const startTime = Date.now();
+            const result = await backend.generateText({
+                messages: [{ role: 'user', content: prompt }],
+            });
+            const duration = Date.now() - startTime;
+            if (outputFormat === 'json') {
+                outputJson(formatSuccess({
+                    model: modelString,
+                    text: result.text,
+                    usage: result.usage,
+                    finishReason: result.finishReason,
+                    duration_ms: duration
+                }));
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.plain(result.text);
+                if (options.verbose) {
+                    await pretty_logger_1.PrettyLogger.newline();
+                    await pretty_logger_1.PrettyLogger.dim(`Model: ${modelString}`);
+                    await pretty_logger_1.PrettyLogger.dim(`Duration: ${duration}ms`);
+                    if (result.usage) {
+                        await pretty_logger_1.PrettyLogger.dim(`Tokens: ${result.usage.totalTokens} (prompt: ${result.usage.promptTokens}, completion: ${result.usage.completionTokens})`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, `Failed to run prompt with model '${modelString}'`);
+    }
+}
+/**
+ * Handle errors with proper exit codes and formatting
+ */
+/**
+ * List common models for each provider
+ */
+async function modelsCommand(args, options, outputFormat) {
+    try {
+        const { listSupportedProviders, AISDK_PROVIDERS } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        // Common models per provider (not exhaustive)
+        const commonModels = {
+            openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-3.5-turbo', 'o1', 'o1-mini'],
+            anthropic: ['claude-3-5-sonnet-latest', 'claude-3-5-haiku-latest', 'claude-3-opus-latest'],
+            google: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+            groq: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'],
+            mistral: ['mistral-large-latest', 'mistral-small-latest', 'codestral-latest'],
+            cohere: ['command-r-plus', 'command-r', 'command-light'],
+            deepseek: ['deepseek-chat', 'deepseek-coder'],
+            xai: ['grok-2', 'grok-2-mini'],
+        };
+        const providers = listSupportedProviders();
+        const modelsData = providers.map((id) => ({
+            provider: id,
+            models: commonModels[id] || ['(check provider docs)'],
+            package: AISDK_PROVIDERS[id]?.package || 'custom'
+        }));
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                note: 'This is not an exhaustive list. Check provider documentation for all available models.',
+                providers: modelsData
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading('Common Models by Provider');
+            await pretty_logger_1.PrettyLogger.dim('Note: This is not exhaustive. Check provider docs for all models.\n');
+            for (const p of modelsData) {
+                await pretty_logger_1.PrettyLogger.plain(`  ${p.provider}:`);
+                for (const model of p.models) {
+                    await pretty_logger_1.PrettyLogger.dim(`    - ${model}`);
+                }
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('Usage: overai llm run "prompt" --model provider/model');
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to list models');
+    }
+}
+/**
+ * Show resolved configuration (redacted)
+ */
+async function configCommand(args, options, outputFormat) {
+    try {
+        const { SAFE_DEFAULTS, AISDK_PROVIDERS, PROVIDER_ALIASES } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        // Gather environment config (redacted)
+        const envConfig = {};
+        for (const [id, info] of Object.entries(AISDK_PROVIDERS)) {
+            const envKey = info.envKey;
+            if (envKey && process.env[envKey]) {
+                envConfig[envKey] = '****' + process.env[envKey].slice(-4);
+            }
+        }
+        const config = {
+            defaults: SAFE_DEFAULTS,
+            aliases: PROVIDER_ALIASES,
+            environment: envConfig,
+            model: options.model || 'openai/gpt-4o-mini',
+            timeout: options.timeout || SAFE_DEFAULTS.timeout,
+        };
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess(config));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading('AI SDK Configuration');
+            await pretty_logger_1.PrettyLogger.plain('  Defaults:');
+            await pretty_logger_1.PrettyLogger.dim(`    timeout: ${SAFE_DEFAULTS.timeout}ms`);
+            await pretty_logger_1.PrettyLogger.dim(`    maxRetries: ${SAFE_DEFAULTS.maxRetries}`);
+            await pretty_logger_1.PrettyLogger.dim(`    maxOutputTokens: ${SAFE_DEFAULTS.maxOutputTokens}`);
+            await pretty_logger_1.PrettyLogger.dim(`    redactLogs: ${SAFE_DEFAULTS.redactLogs}`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Provider Aliases:');
+            for (const [alias, target] of Object.entries(PROVIDER_ALIASES)) {
+                await pretty_logger_1.PrettyLogger.dim(`    ${alias} → ${target}`);
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Environment (redacted):');
+            if (Object.keys(envConfig).length === 0) {
+                await pretty_logger_1.PrettyLogger.dim('    No API keys detected');
+            }
+            else {
+                for (const [key, value] of Object.entries(envConfig)) {
+                    await pretty_logger_1.PrettyLogger.dim(`    ${key}: ${value}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to show config');
+    }
+}
+/**
+ * Demo trace/attribution headers
+ */
+async function traceCommand(args, options, outputFormat) {
+    try {
+        const { createAISDKBackend, createAttributionMiddleware } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+        const modelString = options.model || 'openai/gpt-4o-mini';
+        // Generate demo attribution context
+        const attribution = {
+            agentId: `agent-${Date.now().toString(36)}`,
+            runId: `run-${Math.random().toString(36).slice(2, 10)}`,
+            traceId: `trace-${Math.random().toString(36).slice(2, 10)}`,
+            sessionId: options.verbose ? `session-demo` : undefined,
+        };
+        if (outputFormat !== 'json') {
+            await pretty_logger_1.PrettyLogger.heading('Attribution Trace Demo');
+            await pretty_logger_1.PrettyLogger.info(`Running with model: ${modelString}`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Attribution Context:');
+            await pretty_logger_1.PrettyLogger.dim(`    agentId: ${attribution.agentId}`);
+            await pretty_logger_1.PrettyLogger.dim(`    runId: ${attribution.runId}`);
+            await pretty_logger_1.PrettyLogger.dim(`    traceId: ${attribution.traceId}`);
+            if (attribution.sessionId) {
+                await pretty_logger_1.PrettyLogger.dim(`    sessionId: ${attribution.sessionId}`);
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Headers injected:');
+            await pretty_logger_1.PrettyLogger.dim(`    X-Agent-Id: ${attribution.agentId}`);
+            await pretty_logger_1.PrettyLogger.dim(`    X-Run-Id: ${attribution.runId}`);
+            await pretty_logger_1.PrettyLogger.dim(`    X-Trace-Id: ${attribution.traceId}`);
+            await pretty_logger_1.PrettyLogger.newline();
+        }
+        const backend = createAISDKBackend(modelString, {
+            timeout: options.timeout || 30000,
+            attribution,
+        });
+        const startTime = Date.now();
+        const result = await backend.generateText({
+            messages: [{ role: 'user', content: 'Say "Trace OK" and nothing else.' }],
+            maxTokens: 10,
+        });
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                attribution,
+                headers: {
+                    'X-Agent-Id': attribution.agentId,
+                    'X-Run-Id': attribution.runId,
+                    'X-Trace-Id': attribution.traceId,
+                },
+                response: result.text,
+                duration_ms: duration,
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.success(`Response: ${result.text.trim()} (${duration}ms)`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('Attribution headers are automatically injected into LLM requests.');
+            await pretty_logger_1.PrettyLogger.dim('Use --verbose for session ID.');
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to run trace demo');
+    }
+}
+/**
+ * Demo tool calling - shows how tools work with AI SDK
+ * Note: AI SDK requires Zod schemas for tools, which requires runtime setup
+ */
+async function toolsCommand(args, options, outputFormat) {
+    try {
+        const modelString = options.model || 'openai/gpt-4o-mini';
+        if (outputFormat !== 'json') {
+            await pretty_logger_1.PrettyLogger.heading('Tool Calling Demo');
+            await pretty_logger_1.PrettyLogger.info(`Model: ${modelString}`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  AI SDK Tool Calling requires Zod schemas.');
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Example code:');
+            await pretty_logger_1.PrettyLogger.dim(`    import { generateText, tool } from 'ai';`);
+            await pretty_logger_1.PrettyLogger.dim(`    import { openai } from '@ai-sdk/openai';`);
+            await pretty_logger_1.PrettyLogger.dim(`    import { z } from 'zod';`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.dim(`    const tools = {`);
+            await pretty_logger_1.PrettyLogger.dim(`      get_weather: tool({`);
+            await pretty_logger_1.PrettyLogger.dim(`        description: 'Get weather for a city',`);
+            await pretty_logger_1.PrettyLogger.dim(`        inputSchema: z.object({`);
+            await pretty_logger_1.PrettyLogger.dim(`          city: z.string().describe('City name'),`);
+            await pretty_logger_1.PrettyLogger.dim(`        }),`);
+            await pretty_logger_1.PrettyLogger.dim(`      }),`);
+            await pretty_logger_1.PrettyLogger.dim(`    };`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.dim(`    const result = await generateText({`);
+            await pretty_logger_1.PrettyLogger.dim(`      model: openai('gpt-4o-mini'),`);
+            await pretty_logger_1.PrettyLogger.dim(`      messages: [{ role: 'user', content: 'Weather in Paris?' }],`);
+            await pretty_logger_1.PrettyLogger.dim(`      tools,`);
+            await pretty_logger_1.PrettyLogger.dim(`    });`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('See examples/ai-sdk/tool-calling.ts for a complete example.');
+        }
+        else {
+            outputJson(formatSuccess({
+                model: modelString,
+                note: 'AI SDK tool calling requires Zod schemas at runtime',
+                example: {
+                    import: "import { generateText, tool } from 'ai'; import { z } from 'zod';",
+                    tool: "tool({ description: '...', inputSchema: z.object({ city: z.string() }) })",
+                },
+                docs: 'See examples/ai-sdk/tool-calling.ts',
+            }));
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to run tools demo');
+    }
+}
+/**
+ * Demo structured output (JSON schema) - shows how to use generateObject
+ * Note: AI SDK requires Zod schemas for structured output
+ */
+async function jsonCommand(args, options, outputFormat) {
+    try {
+        const modelString = options.model || 'openai/gpt-4o-mini';
+        if (outputFormat !== 'json') {
+            await pretty_logger_1.PrettyLogger.heading('Structured Output (JSON) Demo');
+            await pretty_logger_1.PrettyLogger.info(`Model: ${modelString}`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  AI SDK Structured Output requires Zod schemas.');
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Example code:');
+            await pretty_logger_1.PrettyLogger.dim(`    import { generateObject } from 'ai';`);
+            await pretty_logger_1.PrettyLogger.dim(`    import { openai } from '@ai-sdk/openai';`);
+            await pretty_logger_1.PrettyLogger.dim(`    import { z } from 'zod';`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.dim(`    const schema = z.object({`);
+            await pretty_logger_1.PrettyLogger.dim(`      name: z.string(),`);
+            await pretty_logger_1.PrettyLogger.dim(`      age: z.number(),`);
+            await pretty_logger_1.PrettyLogger.dim(`      city: z.string(),`);
+            await pretty_logger_1.PrettyLogger.dim(`    });`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.dim(`    const result = await generateObject({`);
+            await pretty_logger_1.PrettyLogger.dim(`      model: openai('gpt-4o-mini'),`);
+            await pretty_logger_1.PrettyLogger.dim(`      schema,`);
+            await pretty_logger_1.PrettyLogger.dim(`      prompt: 'Generate a fictional person profile.',`);
+            await pretty_logger_1.PrettyLogger.dim(`    });`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.dim(`    console.log(result.object); // { name: '...', age: 25, city: '...' }`);
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('See examples/ai-sdk/structured-output.ts for a complete example.');
+        }
+        else {
+            outputJson(formatSuccess({
+                model: modelString,
+                note: 'AI SDK structured output requires Zod schemas at runtime',
+                example: {
+                    import: "import { generateObject } from 'ai'; import { z } from 'zod';",
+                    schema: "z.object({ name: z.string(), age: z.number(), city: z.string() })",
+                },
+                docs: 'See examples/ai-sdk/structured-output.ts',
+            }));
+        }
+    }
+    catch (error) {
+        handleError(error, outputFormat, 'Failed to run JSON demo');
+    }
+}
+/**
+ * Handle errors with proper exit codes and formatting
+ */
+async function handleError(error, outputFormat, context) {
+    const { AISDKError } = await Promise.resolve().then(() => __importStar(require('../../llm/providers/ai-sdk')));
+    let exitCode = LLM_EXIT_CODES.GENERAL_ERROR;
+    let errorCode = 'UNKNOWN_ERROR';
+    let message = context;
+    if (error instanceof AISDKError) {
+        message = `${context}: ${error.message}`;
+        errorCode = error.code;
+        switch (error.code) {
+            case 'AUTHENTICATION':
+                exitCode = 3; // AUTH_ERROR
+                break;
+            case 'PROVIDER_NOT_FOUND':
+            case 'MODEL_NOT_FOUND':
+                exitCode = 4; // PROVIDER_NOT_FOUND
+                break;
+            case 'NETWORK':
+                exitCode = 5; // NETWORK_ERROR
+                break;
+            case 'TIMEOUT':
+                exitCode = 6; // TIMEOUT
+                break;
+            case 'INVALID_REQUEST':
+                exitCode = 2; // INVALID_ARGS
+                break;
+        }
+    }
+    else if (error instanceof Error) {
+        message = `${context}: ${error.message}`;
+    }
+    if (outputFormat === 'json') {
+        outputJson(formatError(errorCode, message));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.error(message);
+    }
+    process.exit(exitCode);
+}