snow-flow 4.2.0 → 4.2.2

package/dist/agent/session.js

@@ -0,0 +1,106 @@
+"use strict";
+// Agent session placeholder to keep build green.
+// Will be replaced with streaming + tool-calling using the AI SDK.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
+const bridge_1 = require("../mcp/bridge");
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+async function runAgent(opts) {
+    const { mcp, system, user, maxSteps = 40, provider, model, baseURL, apiKeyEnv, showReasoning = true, saveOutputPath } = opts;
+    // Resolve model via provider registry
+    let llm;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const prov = require('../llm/providers.js');
+        llm = prov.getModel({ provider, model, baseURL, apiKeyEnv });
+    }
+    catch (e) {
+        console.error('❌ LLM provider init error:', e instanceof Error ? e.message : String(e));
+        throw e;
+    }
+    // Load MCP tools (if AI SDK MCP client is available)
+    const { tools, close } = await (0, bridge_1.loadMCPTools)(mcp);
+    // Stream using AI SDK
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { streamText } = require('ai');
+        const sessionId = (0, store_js_1.createSessionId)();
+        (0, store_js_1.startSession)({
+            id: sessionId,
+            startedAt: new Date().toISOString(),
+            objective: user,
+            provider: { id: String(provider), model: String(model), baseURL },
+            mcp: { cmd: mcp.cmd, args: mcp.args },
+        });
+        (0, store_js_1.appendMessage)(sessionId, { role: 'user', content: user, timestamp: new Date().toISOString() });
+        const result = await streamText({
+            model: llm,
+            system: system ?? 'You are Snow-Flow, a ServiceNow engineering agent. Be precise. Use tools when helpful.',
+            messages: [{ role: 'user', content: user }],
+            tools,
+            maxSteps,
+        });
+        let buffer = '';
+        let inReasoning = false;
+        const writeChunk = (s) => {
+            buffer += s;
+            const colored = inReasoning && showReasoning ? chalk_1.default.yellow.dim(s) : s;
+            process.stdout.write(colored);
+        };
+        // Optional: stream tool call events if provided by SDK
+        if (result.toolCallStream && typeof result.toolCallStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolCallStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const args = ev?.args ? JSON.stringify(ev.args).slice(0, 200) : '';
+                    process.stdout.write('\n' + chalk_1.default.cyan(`🔧 Tool → ${name} ${args}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, argsPreview: args });
+                }
+            })().catch(() => { });
+        }
+        if (result.toolResultStream && typeof result.toolResultStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolResultStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const out = ev?.result ? JSON.stringify(ev.result).slice(0, 200) : '';
+                    process.stdout.write(chalk_1.default.magenta(`📦 Result ← ${name} ${out}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, resultPreview: out });
+                }
+            })().catch(() => { });
+        }
+        for await (const chunk of result.textStream) {
+            const str = String(chunk);
+            // Heuristic: detect reasoning blocks (```reasoning, <thinking>, [reasoning])
+            if (showReasoning) {
+                if (str.includes('```reasoning') || str.toLowerCase().includes('<thinking>') || /\[\s*reasoning\s*\]/i.test(str))
+                    inReasoning = true;
+                if (str.includes('```') || str.toLowerCase().includes('</thinking>'))
+                    inReasoning = false;
+            }
+            writeChunk(str);
+        }
+        // Render a boxed summary if output is long
+        if (buffer.length > 4000) {
+            const preview = buffer.slice(0, 1200) + '…';
+            const box = (0, boxen_1.default)(preview, { padding: 1, borderColor: 'green', title: 'Preview (truncated)', titleAlignment: 'center' });
+            process.stdout.write('\n' + box + '\n');
+            process.stdout.write(chalk_1.default.gray(`Full length: ${buffer.length} chars`) + '\n');
+        }
+        if (saveOutputPath) {
+            const fs = require('fs');
+            fs.writeFileSync(saveOutputPath, buffer, 'utf8');
+            process.stdout.write(chalk_1.default.gray(`Saved full output to ${saveOutputPath}`) + '\n');
+        }
+        (0, store_js_1.appendMessage)(sessionId, { role: 'assistant', content: buffer, timestamp: new Date().toISOString() });
+        (0, store_js_1.endSession)(sessionId);
+    }
+    finally {
+        await close();
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/cli/auth.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerAuthCommands(program: Command): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/auth.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthCommands = registerAuthCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const keys_js_1 = require("../llm/keys.js");
+function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Manage provider API credentials for Snow-Flow');
+    auth
+        .command('login')
+        .description('Interactive login to store API keys for a provider')
+        .option('--provider <provider>', 'Provider id (openai|google|openrouter|openai-compatible|ollama)')
+        .action(async (opts) => {
+        const p = opts.provider || (await inquirer_1.default.prompt([{ name: 'provider', message: 'Provider', type: 'list', choices: ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'] }])).provider;
+        const existing = (0, keys_js_1.getApiKey)(p);
+        const { apiKey } = await inquirer_1.default.prompt([{ name: 'apiKey', message: `API key for ${p}${existing ? ' (leave blank to keep existing)' : ''}`, type: 'password', mask: '*' }]);
+        if (!apiKey && existing) {
+            console.log(chalk_1.default.yellow('Keeping existing key.'));
+            return;
+        }
+        if (!apiKey) {
+            console.error(chalk_1.default.red('No key entered. Aborting.'));
+            process.exit(1);
+        }
+        (0, keys_js_1.setApiKey)(p, apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${p}.`));
+    });
+    auth
+        .command('set-key')
+        .description('Set API key non-interactively')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .requiredOption('--api-key <key>', 'API key value')
+        .action((opts) => {
+        (0, keys_js_1.setApiKey)(opts.provider, opts.apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${opts.provider}.`));
+    });
+    auth
+        .command('show')
+        .description('Show configured providers (keys partially masked)')
+        .action(() => {
+        const entries = (0, keys_js_1.listKeys)();
+        for (const [p, v] of Object.entries(entries)) {
+            const mask = v ? `${v.substring(0, 4)}…${v.substring(v.length - 4)}` : '—';
+            console.log(`${p.padEnd(18)} ${mask}`);
+        }
+    });
+    auth
+        .command('clear')
+        .description('Clear a stored API key')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .action((opts) => {
+        (0, keys_js_1.clearApiKey)(opts.provider);
+        console.log(chalk_1.default.yellow(`Cleared API key for ${opts.provider}.`));
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/session.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerSessionCommands(program: Command): void;
+//# sourceMappingURL=session.d.ts.map

package/dist/cli/session.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionCommands = registerSessionCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+function registerSessionCommands(program) {
+    const sess = program.command('session').description('Manage and inspect Snow-Flow sessions');
+    sess
+        .command('list')
+        .description('List recent sessions')
+        .action(() => {
+        const rows = (0, store_js_1.listSessions)().slice(0, 30);
+        if (!rows.length)
+            return console.log('No sessions yet.');
+        for (const r of rows) {
+            console.log(`${chalk_1.default.gray(r.startedAt)}  ${chalk_1.default.cyan(r.id)}  ${r.objective}`);
+        }
+    });
+    sess
+        .command('show <id>')
+        .description('Show session details')
+        .action((id) => {
+        const rec = (0, store_js_1.readSession)(id);
+        if (!rec)
+            return console.error(chalk_1.default.red('Session not found.'));
+        console.log(chalk_1.default.cyan(`Session ${rec.id}`));
+        console.log(`${chalk_1.default.gray(rec.startedAt)} → ${chalk_1.default.gray(rec.endedAt ?? '…')}`);
+        console.log('Objective:', rec.objective);
+        console.log('Provider:', `${rec.provider.id} ${rec.provider.model}`);
+        console.log('MCP:', `${rec.mcp.cmd} ${(rec.mcp.args || []).join(' ')}`);
+        console.log('\nMessages:');
+        for (const m of rec.messages) {
+            console.log(`- ${chalk_1.default.yellow(m.role)} ${chalk_1.default.gray(m.timestamp)}\n  ${m.content.slice(0, 400)}${m.content.length > 400 ? '…' : ''}`);
+        }
+        if (rec.toolEvents?.length) {
+            console.log('\nTool events:');
+            for (const ev of rec.toolEvents) {
+                console.log(`  🔧 ${ev.name} ${chalk_1.default.gray(ev.when)} ${ev.argsPreview ? ('args:' + ev.argsPreview) : ''} ${ev.resultPreview ? ('res:' + ev.resultPreview) : ''}`);
+            }
+        }
+    });
+}
+//# sourceMappingURL=session.js.map

package/dist/cli.js

@@ -53,6 +53,11 @@ const agent_detector_js_1 = require("./utils/agent-detector.js");
 const version_js_1 = require("./version.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
+// New provider-agnostic engine imports (compile-safe placeholders)
+const llm_config_loader_js_1 = require("./config/llm-config-loader.js");
+const interactive_js_1 = require("./agent/interactive.js");
+const auth_js_1 = require("./cli/auth.js");
+const session_js_1 = require("./cli/session.js");
 // Load environment variables
 dotenv_1.default.config();
 // Create CLI logger instance
@@ -62,6 +67,10 @@ program
     .name('snow-flow')
     .description('ServiceNow Multi-Agent Development Framework')
     .version(version_js_1.VERSION);
+// Register auth commands (API key management)
+(0, auth_js_1.registerAuthCommands)(program);
+// Register session inspection commands
+(0, session_js_1.registerSessionCommands)(program);
 // Flow deprecation handler - check for flow-related commands
 function checkFlowDeprecation(command, objective) {
     const flowKeywords = ['flow', 'create-flow', 'xml-flow', 'flow-designer'];
@@ -90,6 +99,18 @@ function checkFlowDeprecation(command, objective) {
 program
     .command('swarm <objective>')
     .description('Execute multi-agent orchestration for a ServiceNow task - één command voor alles!')
+    // New engine selector: defaults to auto (uses config-driven agent when available)
+    .option('--engine <engine>', 'Execution engine (auto|agent|claude)', 'auto')
+    .option('--config <path>', 'Path to snowflow.config file')
+    .option('--show-reasoning', 'Show LLM reasoning in a different color (default)', true)
+    .option('--no-show-reasoning', 'Hide LLM reasoning blocks')
+    .option('--save-output <path>', 'Save full assistant output to a file')
+    .option('--resume <sessionId>', 'Resume an existing interactive session')
+    // Provider overrides (optional, config-driven by default)
+    .option('--provider <provider>', 'LLM provider override')
+    .option('--model <model>', 'Model override')
+    .option('--base-url <url>', 'Base URL override for openai-compatible or gateways')
+    .option('--api-key-env <name>', 'Use specific API key env var')
     .option('--strategy <strategy>', 'Execution strategy (development, _analysis, research)', 'development')
     .option('--mode <mode>', 'Coordination mode (hierarchical, mesh, distributed)', 'hierarchical')
     .option('--max-agents <number>', 'Maximum number of agents', '5')
@@ -266,6 +287,66 @@ program
             cliLogger.info(`🤖 Autonomous Systems: ❌ All Disabled`);
         }
     }
+    // Detect agent engine via config (provider-agnostic) when requested or available
+    const shouldUseAgent = (() => {
+        if (options.engine === 'agent')
+            return true;
+        if (options.engine === 'claude')
+            return false;
+        // auto: use agent when config file is present and valid
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        return Boolean(cfg && cfg.llm && cfg.llm.provider && cfg.llm.model);
+    })();
+    if (shouldUseAgent) {
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        if (!cfg) {
+            cliLogger.error('❌ Geen snowflow.config.(json|js|cjs) gevonden. Voeg config toe of gebruik --engine claude.');
+            process.exit(1);
+        }
+        // Basic validation for MVP
+        if (!cfg.llm?.provider || !cfg.llm?.model) {
+            cliLogger.error('❌ Config mist llm.provider of llm.model');
+            process.exit(1);
+        }
+        cliLogger.info('\n🤖 Using provider-agnostic Snow-Flow agent (interactive)');
+        try {
+            await (0, interactive_js_1.runInteractive)({
+                provider: cfg.llm.provider,
+                model: String(cfg.llm.model),
+                baseURL: cfg.llm.baseURL,
+                apiKeyEnv: cfg.llm.apiKeyEnv,
+                mcp: cfg.mcp,
+                system: cfg.agent?.system,
+                maxSteps: cfg.agent?.maxSteps ?? 40,
+                showReasoning: options.showReasoning !== false,
+                resumeId: options.resume || undefined,
+            });
+        }
+        catch (e) {
+            cliLogger.error('❌ Interactive agent error:', e instanceof Error ? e.message : String(e));
+        }
+        return; // end here; skip legacy Claude path
+    }
     // Analyze the objective using intelligent agent detection
     const taskAnalysis = analyzeObjective(objective, parseInt(options.maxAgents));
     // Debug logging to understand task type detection

package/dist/config/llm-config-loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LLM Config Loader
+ * Loads Snow-Flow configuration with LLM provider settings
+ */
+export interface SnowFlowConfig {
+    instance?: string;
+    username?: string;
+    password?: string;
+    client_id?: string;
+    client_secret?: string;
+    refresh_token?: string;
+    debug?: boolean;
+    llm?: {
+        provider?: string;
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+        apiKeyEnv?: string;
+    };
+    mcp?: {
+        enabled?: boolean;
+        servers?: string[];
+    };
+    agent?: {
+        maxWorkers?: number;
+        timeout?: number;
+        system?: any;
+        maxSteps?: number;
+    };
+}
+/**
+ * Load Snow-Flow configuration with optional LLM settings
+ */
+export declare function loadSnowFlowConfig(): SnowFlowConfig;
+/**
+ * Get LLM configuration specifically
+ */
+export declare function getLLMConfig(): {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    baseURL?: string;
+    apiKeyEnv?: string;
+};
+//# sourceMappingURL=llm-config-loader.d.ts.map

package/dist/config/llm-config-loader.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * LLM Config Loader
+ * Loads Snow-Flow configuration with LLM provider settings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSnowFlowConfig = loadSnowFlowConfig;
+exports.getLLMConfig = getLLMConfig;
+const snow_flow_config_js_1 = require("./snow-flow-config.js");
+/**
+ * Load Snow-Flow configuration with optional LLM settings
+ */
+function loadSnowFlowConfig() {
+    try {
+        // Load base config from snow-flow-config
+        const baseConfig = snow_flow_config_js_1.snowFlowConfig || {};
+        // Add LLM configuration if available
+        const config = {
+            ...baseConfig,
+            llm: {
+                provider: process.env.LLM_PROVIDER || 'claude',
+                model: process.env.LLM_MODEL || 'claude-3-sonnet',
+                apiKey: process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY
+            }
+        };
+        return config;
+    }
+    catch (error) {
+        // Fallback to basic config
+        return {
+            debug: false,
+            llm: {
+                provider: 'claude',
+                model: 'claude-3-sonnet'
+            }
+        };
+    }
+}
+/**
+ * Get LLM configuration specifically
+ */
+function getLLMConfig() {
+    const config = loadSnowFlowConfig();
+    return config.llm || {
+        provider: 'claude',
+        model: 'claude-3-sonnet'
+    };
+}
+//# sourceMappingURL=llm-config-loader.js.map

package/dist/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemHealth = exports.PerformanceTracker = exports.FALLBACK_STRATEGIES = exports.ErrorRecovery = exports.MemorySystem = exports.snowFlowConfig = exports.SnowFlowConfig = exports.snowFlowSystem = exports.SnowFlowSystem = exports.ServiceNowLocalDevelopmentMCP = exports.ServiceNowMCPServer = exports.SmartFieldFetcher = exports.ArtifactLocalSync = exports.Logger = exports.ServiceNowClient = exports.ServiceNowOAuth = void 0;
+exports.SystemHealth = exports.PerformanceTracker = exports.FALLBACK_STRATEGIES = exports.ErrorRecovery = exports.snowFlowConfig = exports.SnowFlowConfig = exports.snowFlowSystem = exports.SnowFlowSystem = exports.ServiceNowLocalDevelopmentMCP = exports.ServiceNowMCPServer = exports.SmartFieldFetcher = exports.ArtifactLocalSync = exports.Logger = exports.ServiceNowClient = exports.ServiceNowOAuth = void 0;
 // Export main types
 __exportStar(require("./types/index.js"), exports);
 // Export utilities
@@ -46,8 +46,6 @@ Object.defineProperty(exports, "snowFlowSystem", { enumerable: true, get: functi
 var snow_flow_config_js_1 = require("./config/snow-flow-config.js");
 Object.defineProperty(exports, "SnowFlowConfig", { enumerable: true, get: function () { return snow_flow_config_js_1.SnowFlowConfig; } });
 Object.defineProperty(exports, "snowFlowConfig", { enumerable: true, get: function () { return snow_flow_config_js_1.snowFlowConfig; } });
-var memory_system_js_1 = require("./memory/memory-system.js");
-Object.defineProperty(exports, "MemorySystem", { enumerable: true, get: function () { return memory_system_js_1.MemorySystem; } });
 var error_recovery_js_1 = require("./utils/error-recovery.js");
 Object.defineProperty(exports, "ErrorRecovery", { enumerable: true, get: function () { return error_recovery_js_1.ErrorRecovery; } });
 Object.defineProperty(exports, "FALLBACK_STRATEGIES", { enumerable: true, get: function () { return error_recovery_js_1.FALLBACK_STRATEGIES; } });

package/dist/intelligence/performance-recommendations-engine.js

@@ -14,7 +14,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerformanceRecommendationsEngine = void 0;
 const logger_js_1 = require("../utils/logger.js");
-const memory_system_js_1 = require("../memory/memory-system.js");
 class PerformanceRecommendationsEngine {
     constructor(memory) {
         this.performancePatterns = new Map();

package/dist/llm/keys.d.ts

@@ -0,0 +1,5 @@
+export declare function setApiKey(provider: string, value: string): void;
+export declare function getApiKey(provider: string): string | undefined;
+export declare function clearApiKey(provider: string): void;
+export declare function listKeys(): Record<string, string | undefined>;
+//# sourceMappingURL=keys.d.ts.map

package/dist/llm/keys.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApiKey = setApiKey;
+exports.getApiKey = getApiKey;
+exports.clearApiKey = clearApiKey;
+exports.listKeys = listKeys;
+const conf_1 = __importDefault(require("conf"));
+// Avoid generic type for broader compatibility with shimmed types
+const store = new conf_1.default({ projectName: 'snow-flow' });
+function setApiKey(provider, value) {
+    store.set(`keys.${provider}`, value);
+}
+function getApiKey(provider) {
+    return store.get(`keys.${provider}`);
+}
+function clearApiKey(provider) {
+    store.delete(`keys.${provider}`);
+}
+function listKeys() {
+    const providers = ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'];
+    const out = {};
+    for (const p of providers)
+        out[p] = getApiKey(p);
+    return out;
+}
+//# sourceMappingURL=keys.js.map

package/dist/llm/providers.d.ts

@@ -0,0 +1,11 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+export type ProviderId = SnowFlowConfig['llm']['provider'];
+export interface ProviderOptions {
+    provider: ProviderId;
+    model: string;
+    baseURL?: string;
+    apiKeyEnv?: string;
+    extraBody?: Record<string, unknown>;
+}
+export declare function getModel(opts: ProviderOptions): unknown;
+//# sourceMappingURL=providers.d.ts.map

package/dist/llm/providers.js

@@ -0,0 +1,77 @@
+"use strict";
+// Compile-safe placeholder registry. Real providers will be wired via AI SDK in a follow-up step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const keys_js_1 = require("./keys.js");
+function getModel(opts) {
+    const { provider, model, baseURL, apiKeyEnv, extraBody } = opts;
+    const requireOrThrow = (name) => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            return require(name);
+        }
+        catch (err) {
+            const hint = `Missing dependency ${name}. Run: npm i ai @ai-sdk/openai @ai-sdk/google @openrouter/ai-sdk-provider`;
+            throw new Error(hint);
+        }
+    };
+    switch (provider) {
+        case 'anthropic': {
+            // Prefer AI SDK anthropic provider if installed; otherwise instruct
+            try {
+                // Dynamic require to avoid hard dep
+                const anthropic = require('@ai-sdk/anthropic');
+                const key = process.env[apiKeyEnv || 'ANTHROPIC_API_KEY'] || (0, keys_js_1.getApiKey)('anthropic');
+                if (!key)
+                    throw new Error('Missing ANTHROPIC_API_KEY');
+                return anthropic.anthropic({ apiKey: key, baseURL }).languageModel(model);
+            }
+            catch (e) {
+                throw new Error('Anthropic provider not available. Install @ai-sdk/anthropic or use OpenRouter with an Anthropic model.');
+            }
+        }
+        case 'openai': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const apiKey = process.env[apiKeyEnv || 'OPENAI_API_KEY'] || (0, keys_js_1.getApiKey)('openai');
+            if (!apiKey)
+                throw new Error('Missing OPENAI_API_KEY');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'google': {
+            const { google } = requireOrThrow('@ai-sdk/google');
+            const apiKey = process.env[apiKeyEnv || 'GOOGLE_API_KEY']
+                || process.env['GOOGLE_GENERATIVE_AI_API_KEY']
+                || (0, keys_js_1.getApiKey)('google');
+            if (!apiKey)
+                throw new Error('Missing GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY');
+            return google({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'openrouter': {
+            const { createOpenRouter } = requireOrThrow('@openrouter/ai-sdk-provider');
+            const apiKey = process.env[apiKeyEnv || 'OPENROUTER_API_KEY'] || (0, keys_js_1.getApiKey)('openrouter');
+            if (!apiKey)
+                throw new Error('Missing OPENROUTER_API_KEY');
+            const or = createOpenRouter({ apiKey, baseURL, extraBody });
+            return or(model);
+        }
+        case 'openai-compatible': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OPENAI_COMPAT_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('openai-compatible');
+            if (!baseURL)
+                throw new Error('openai-compatible requires baseURL');
+            if (!apiKey)
+                throw new Error(`Missing ${keyName}`);
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'ollama': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OLLAMA_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('ollama');
+            if (!baseURL)
+                throw new Error('ollama requires baseURL (e.g., http://localhost:11434/v1)');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+    }
+}
+//# sourceMappingURL=providers.js.map