@orchagent/cli 0.2.25 → 0.3.0

package/dist/adapters/agents-md.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsMdAdapter = void 0;
+exports.agentsMdAdapter = {
+    id: 'agents-md',
+    name: 'AGENTS.md (Universal)',
+    version: '1.0.0',
+    formatVersion: '1.0',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'project',
+            path: './',
+            description: 'Project root (AGENTS.md)',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to AGENTS.md');
+            return { canConvert: false, warnings, errors };
+        }
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        warnings.push('AGENTS.md content should be appended to existing file, not replaced');
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const agentRef = `${agent.org_slug}/${agent.name}`;
+        const description = agent.description || '';
+        // Use orchagent markers for managed section
+        const content = `<!-- orchagent:${agentRef} -->
+## ${agent.name}
+
+${description}
+
+${agent.prompt || ''}
+<!-- /orchagent:${agentRef} -->
+`;
+        return [
+            {
+                filename: 'AGENTS.md',
+                content,
+                installPath: './',
+            },
+        ];
+    },
+};

package/dist/adapters/claude-code.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeCodeAdapter = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+// Map Anthropic model names to Claude Code aliases
+function mapModelToAlias(model) {
+    if (!model)
+        return 'inherit';
+    const lower = model.toLowerCase();
+    if (lower.includes('opus'))
+        return 'opus';
+    if (lower.includes('haiku'))
+        return 'haiku';
+    // Default to sonnet for any Claude model
+    if (lower.includes('claude') || lower.includes('sonnet'))
+        return 'sonnet';
+    return 'inherit';
+}
+// Convert agent name to valid Claude Code name (lowercase + hyphens)
+function normalizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+exports.claudeCodeAdapter = {
+    id: 'claude-code',
+    name: 'Claude Code Sub-Agent',
+    version: '1.0.0',
+    formatVersion: '2026-01',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'user',
+            path: '~/.claude/agents/',
+            description: 'User-level (available in all projects)',
+        },
+        {
+            scope: 'project',
+            path: '.claude/agents/',
+            description: 'Project-level (current directory)',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        // Code agents cannot be converted
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to Claude Code sub-agents (they require execution)');
+            return { canConvert: false, warnings, errors };
+        }
+        // Check for prompt
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        // Warnings for fields that can't be fully mapped
+        if (agent.input_schema) {
+            warnings.push('input_schema will be described in the prompt body, not enforced');
+        }
+        if (agent.output_schema) {
+            warnings.push('output_schema will be described in the prompt body, not enforced');
+        }
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const normalizedName = normalizeAgentName(agent.name);
+        // Build frontmatter
+        const frontmatter = {
+            name: normalizedName,
+            description: agent.description || `Delegatable agent: ${agent.name}`,
+            tools: 'Read, Glob, Grep', // Safe defaults - read-only
+        };
+        // Map model if specified
+        if (agent.default_models?.anthropic) {
+            const modelAlias = mapModelToAlias(agent.default_models.anthropic);
+            if (modelAlias !== 'inherit') {
+                frontmatter.model = modelAlias;
+            }
+        }
+        // Build body
+        let body = agent.prompt || '';
+        // Add schema descriptions if present
+        if (agent.input_schema) {
+            body += `\n\n## Input Schema\n\nThis agent expects input matching:\n\`\`\`json\n${JSON.stringify(agent.input_schema, null, 2)}\n\`\`\``;
+        }
+        if (agent.output_schema) {
+            body += `\n\n## Output Schema\n\nThis agent should return output matching:\n\`\`\`json\n${JSON.stringify(agent.output_schema, null, 2)}\n\`\`\``;
+        }
+        // Combine frontmatter + body
+        const content = `---\n${yaml_1.default.stringify(frontmatter).trim()}\n---\n\n${body.trim()}\n`;
+        return [
+            {
+                filename: `${normalizedName}.md`,
+                content,
+                installPath: '.claude/agents/',
+            },
+        ];
+    },
+};

package/dist/adapters/cursor.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorAdapter = void 0;
+// Convert agent name to valid filename (lowercase + hyphens)
+function normalizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+exports.cursorAdapter = {
+    id: 'cursor',
+    name: 'Cursor Rules',
+    version: '1.0.0',
+    formatVersion: '2026-01',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'project',
+            path: '.cursor/rules/',
+            description: 'Project-level Cursor rules',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to Cursor rules');
+            return { canConvert: false, warnings, errors };
+        }
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        // Cursor doesn't support input/output schemas
+        if (agent.input_schema) {
+            warnings.push('input_schema is not supported in Cursor rules');
+        }
+        if (agent.output_schema) {
+            warnings.push('output_schema is not supported in Cursor rules');
+        }
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const normalizedName = normalizeAgentName(agent.name);
+        const description = agent.description || `Rules from ${agent.name}`;
+        // Cursor .mdc format
+        const content = `---
+description: ${description}
+globs:
+alwaysApply: false
+---
+
+# ${agent.name}
+
+${agent.prompt || ''}
+`;
+        return [
+            {
+                filename: `${normalizedName}.mdc`,
+                content,
+                installPath: '.cursor/rules/',
+            },
+        ];
+    },
+};

package/dist/adapters/index.js

@@ -0,0 +1,38 @@
+"use strict";
+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 __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.agentsMdAdapter = exports.cursorAdapter = exports.claudeCodeAdapter = exports.adapterRegistry = exports.AdapterRegistry = void 0;
+// Export types
+__exportStar(require("./types"), exports);
+// Export registry
+const registry_1 = require("./registry");
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "AdapterRegistry", { enumerable: true, get: function () { return registry_2.AdapterRegistry; } });
+Object.defineProperty(exports, "adapterRegistry", { enumerable: true, get: function () { return registry_2.adapterRegistry; } });
+// Import and register adapters
+const claude_code_1 = require("./claude-code");
+var claude_code_2 = require("./claude-code");
+Object.defineProperty(exports, "claudeCodeAdapter", { enumerable: true, get: function () { return claude_code_2.claudeCodeAdapter; } });
+const cursor_1 = require("./cursor");
+var cursor_2 = require("./cursor");
+Object.defineProperty(exports, "cursorAdapter", { enumerable: true, get: function () { return cursor_2.cursorAdapter; } });
+const agents_md_1 = require("./agents-md");
+var agents_md_2 = require("./agents-md");
+Object.defineProperty(exports, "agentsMdAdapter", { enumerable: true, get: function () { return agents_md_2.agentsMdAdapter; } });
+// Register built-in adapters
+registry_1.adapterRegistry.register(claude_code_1.claudeCodeAdapter);
+registry_1.adapterRegistry.register(cursor_1.cursorAdapter);
+registry_1.adapterRegistry.register(agents_md_1.agentsMdAdapter);

package/dist/adapters/registry.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterRegistry = exports.AdapterRegistry = void 0;
+class AdapterRegistry {
+    adapters = new Map();
+    /**
+     * Register an adapter
+     */
+    register(adapter) {
+        if (this.adapters.has(adapter.id)) {
+            throw new Error(`Adapter '${adapter.id}' is already registered`);
+        }
+        this.adapters.set(adapter.id, adapter);
+    }
+    /**
+     * Get adapter by ID
+     */
+    get(id) {
+        return this.adapters.get(id);
+    }
+    /**
+     * List all registered adapters
+     */
+    list() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * Find adapters compatible with an agent
+     */
+    findCompatible(agent) {
+        return this.list().filter(adapter => {
+            const result = adapter.canConvert(agent);
+            return result.canConvert;
+        });
+    }
+    /**
+     * Check if an adapter ID is valid
+     */
+    has(id) {
+        return this.adapters.has(id);
+    }
+    /**
+     * Get all adapter IDs
+     */
+    getIds() {
+        return Array.from(this.adapters.keys());
+    }
+}
+exports.AdapterRegistry = AdapterRegistry;
+// Global registry instance
+exports.adapterRegistry = new AdapterRegistry();

package/dist/adapters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/config.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const config_1 = require("../lib/config");
+const errors_1 = require("../lib/errors");
+const SUPPORTED_KEYS = ['default-format'];
+function isValidKey(key) {
+    return SUPPORTED_KEYS.includes(key);
+}
+async function setConfigValue(key, value) {
+    if (!isValidKey(key)) {
+        throw new errors_1.CliError(`Unknown config key: ${key}. Supported keys: ${SUPPORTED_KEYS.join(', ')}`);
+    }
+    if (key === 'default-format') {
+        const formats = value.split(',').map((f) => f.trim()).filter(Boolean);
+        // Validate all format IDs
+        const invalidFormats = formats.filter((f) => !config_1.VALID_FORMAT_IDS.includes(f));
+        if (invalidFormats.length > 0) {
+            throw new errors_1.CliError(`Invalid format ID(s): ${invalidFormats.join(', ')}. Valid formats: ${config_1.VALID_FORMAT_IDS.join(', ')}`);
+        }
+        await (0, config_1.setDefaultFormats)(formats);
+        process.stdout.write(`Set default-format to: ${formats.join(',')}\n`);
+    }
+}
+async function getConfigValue(key) {
+    if (!isValidKey(key)) {
+        throw new errors_1.CliError(`Unknown config key: ${key}. Supported keys: ${SUPPORTED_KEYS.join(', ')}`);
+    }
+    if (key === 'default-format') {
+        const formats = await (0, config_1.getDefaultFormats)();
+        if (formats.length === 0) {
+            process.stdout.write('(not set)\n');
+        }
+        else {
+            process.stdout.write(`${formats.join(',')}\n`);
+        }
+    }
+}
+async function listConfigValues() {
+    const config = await (0, config_1.loadConfig)();
+    process.stdout.write('CLI Configuration:\n\n');
+    // default-format
+    const formats = config.default_formats ?? [];
+    if (formats.length > 0) {
+        process.stdout.write(`  default-format: ${formats.join(',')}\n`);
+    }
+    else {
+        process.stdout.write('  default-format: (not set)\n');
+    }
+    process.stdout.write('\n');
+}
+function registerConfigCommand(program) {
+    const config = program
+        .command('config')
+        .description('Manage CLI configuration');
+    config
+        .command('set <key> <value>')
+        .description('Set a configuration value')
+        .action(async (key, value) => {
+        await setConfigValue(key, value);
+    });
+    config
+        .command('get <key>')
+        .description('Get a configuration value')
+        .action(async (key) => {
+        await getConfigValue(key);
+    });
+    config
+        .command('list')
+        .description('List all configuration values')
+        .action(async () => {
+        await listConfigValues();
+    });
+}

package/dist/commands/formats.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFormatsCommand = registerFormatsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const adapters_1 = require("../adapters");
+function registerFormatsCommand(program) {
+    program
+        .command('formats')
+        .description('List available export formats for agents')
+        .option('--json', 'Output raw JSON')
+        .action(async (options) => {
+        const adapters = adapters_1.adapterRegistry.list();
+        if (options.json) {
+            const data = adapters.map(a => ({
+                id: a.id,
+                name: a.name,
+                version: a.version,
+                formatVersion: a.formatVersion,
+                supportsAgentTypes: a.supportsAgentTypes,
+                installPaths: a.installPaths,
+            }));
+            process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+            return;
+        }
+        process.stdout.write('\nAvailable export formats:\n\n');
+        for (const adapter of adapters) {
+            process.stdout.write(`  ${chalk_1.default.cyan(adapter.id)}    ${adapter.name}\n`);
+            process.stdout.write(`               Supports: ${adapter.supportsAgentTypes.join(', ')} agents\n`);
+            process.stdout.write(`               Format version: ${adapter.formatVersion}\n`);
+            for (const installPath of adapter.installPaths) {
+                const pathDisplay = installPath.scope === 'user'
+                    ? installPath.path
+                    : installPath.path;
+                process.stdout.write(`               ${installPath.scope}: ${pathDisplay}\n`);
+            }
+            process.stdout.write('\n');
+        }
+        process.stdout.write('Use with: orch install <agent> --format <id>\n');
+        process.stdout.write('Set default: orch config set default-format <ids>\n\n');
+    });
+}

package/dist/commands/index.js

@@ -21,6 +21,10 @@ const status_1 = require("./status");
 const workspace_1 = require("./workspace");
 const tree_1 = require("./tree");
 const docs_1 = require("./docs");
+const config_1 = require("./config");
+const install_1 = require("./install");
+const formats_1 = require("./formats");
+const update_1 = require("./update");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -42,4 +46,8 @@ function registerCommands(program) {
     (0, workspace_1.registerWorkspaceCommand)(program);
     (0, tree_1.registerTreeCommand)(program);
     (0, docs_1.registerDocsCommand)(program);
+    (0, config_1.registerConfigCommand)(program);
+    (0, install_1.registerInstallCommand)(program);
+    (0, formats_1.registerFormatsCommand)(program);
+    (0, update_1.registerUpdateCommand)(program);
 }

package/dist/commands/install.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallCommand = registerInstallCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const adapters_1 = require("../adapters");
+const installed_1 = require("../lib/installed");
+const DEFAULT_VERSION = 'v1';
+function parseAgentRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { name: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], name: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
+}
+async function downloadAgentWithFallback(config, org, name, version) {
+    // Try public endpoint first
+    try {
+        const agent = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/${version}`);
+        return { ...agent, org_slug: org };
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint for private agents
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === name);
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    let targetAgent;
+    if (version === 'latest') {
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    else {
+        const found = matching.find(a => a.version === version);
+        if (!found) {
+            throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+        }
+        targetAgent = found;
+    }
+    return { ...targetAgent, org_slug: org };
+}
+function registerInstallCommand(program) {
+    program
+        .command('install <agent>')
+        .description('Install agent as sub-agent (Claude Code, Cursor, etc.)')
+        .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
+        .option('--scope <scope>', 'Install scope: user (home dir) or project (current dir)', 'user')
+        .option('--dry-run', 'Show what would be installed without making changes')
+        .action(async (agentArg, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const parsed = parseAgentRef(agentArg);
+        const org = parsed.org ?? resolved.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
+        // Determine target formats
+        let targetFormats = [];
+        if (options.format) {
+            targetFormats = options.format.split(',').map(f => f.trim());
+            const invalid = targetFormats.filter(f => !adapters_1.adapterRegistry.has(f));
+            if (invalid.length > 0) {
+                throw new errors_1.CliError(`Unknown format(s): ${invalid.join(', ')}. Available: ${adapters_1.adapterRegistry.getIds().join(', ')}`);
+            }
+        }
+        else {
+            const defaults = await (0, config_1.getDefaultFormats)();
+            if (defaults.length > 0) {
+                targetFormats = defaults;
+            }
+            else {
+                // No default configured - use claude-code as sensible default
+                targetFormats = ['claude-code'];
+            }
+        }
+        // Validate scope
+        const scope = options.scope;
+        if (scope !== 'user' && scope !== 'project') {
+            throw new errors_1.CliError('Scope must be "user" or "project"');
+        }
+        // Download agent
+        process.stdout.write(`Fetching ${org}/${parsed.name}@${parsed.version}...\n`);
+        const agent = await downloadAgentWithFallback(resolved, org, parsed.name, parsed.version);
+        // Install for each format
+        for (const formatId of targetFormats) {
+            const adapter = adapters_1.adapterRegistry.get(formatId);
+            if (!adapter) {
+                process.stderr.write(`Warning: Unknown format '${formatId}', skipping\n`);
+                continue;
+            }
+            // Check if can convert
+            const checkResult = adapter.canConvert(agent);
+            if (!checkResult.canConvert) {
+                process.stderr.write(`Cannot convert to ${adapter.name}:\n`);
+                for (const err of checkResult.errors) {
+                    process.stderr.write(`  - ${err}\n`);
+                }
+                continue;
+            }
+            // Show warnings
+            for (const warn of checkResult.warnings) {
+                process.stdout.write(`Warning (${formatId}): ${warn}\n`);
+            }
+            // Convert
+            const files = adapter.convert(agent);
+            // Determine base directory
+            const baseDir = scope === 'user' ? os_1.default.homedir() : process.cwd();
+            // Install each file
+            for (const file of files) {
+                const fullDir = path_1.default.join(baseDir, file.installPath);
+                const fullPath = path_1.default.join(fullDir, file.filename);
+                if (options.dryRun) {
+                    process.stdout.write(`Would install: ${fullPath}\n`);
+                    process.stdout.write(`Content preview:\n${file.content.slice(0, 500)}...\n\n`);
+                    continue;
+                }
+                // Create directory and write file
+                await promises_1.default.mkdir(fullDir, { recursive: true });
+                await promises_1.default.writeFile(fullPath, file.content);
+                // Track installation
+                const installedAgent = {
+                    agent: `${org}/${parsed.name}`,
+                    version: parsed.version,
+                    format: formatId,
+                    scope,
+                    path: fullPath,
+                    installedAt: new Date().toISOString(),
+                    adapterVersion: adapter.version,
+                    contentHash: (0, installed_1.computeHash)(file.content),
+                };
+                await (0, installed_1.trackInstall)(installedAgent);
+                process.stdout.write(`Installed: ${fullPath}\n`);
+            }
+        }
+        if (!options.dryRun) {
+            await (0, analytics_1.track)('cli_agent_install', {
+                agent: `${org}/${parsed.name}`,
+                formats: targetFormats,
+                scope,
+            });
+            process.stdout.write(`\nAgent installed successfully!\n`);
+            if (scope === 'user') {
+                process.stdout.write(`Available in all your projects.\n`);
+            }
+            else {
+                process.stdout.write(`Available in this project only.\n`);
+            }
+        }
+    });
+}

package/dist/commands/run.js

@@ -234,6 +234,58 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
         }
     }
 }
+/**
+ * Detect all available LLM providers from environment and server.
+ * Returns array of provider configs for fallback support.
+ */
+async function detectAllLlmKeys(supportedProviders, config) {
+    const providers = [];
+    const seen = new Set();
+    // Check environment variables for all providers
+    for (const provider of supportedProviders) {
+        if (provider === 'any') {
+            // Check all known providers
+            for (const [p, envVar] of Object.entries(llm_1.PROVIDER_ENV_VARS)) {
+                const key = process.env[envVar];
+                if (key && !seen.has(p)) {
+                    seen.add(p);
+                    providers.push({ provider: p, apiKey: key, model: (0, llm_1.getDefaultModel)(p) });
+                }
+            }
+        }
+        else {
+            const envVar = llm_1.PROVIDER_ENV_VARS[provider];
+            if (envVar) {
+                const key = process.env[envVar];
+                if (key && !seen.has(provider)) {
+                    seen.add(provider);
+                    providers.push({ provider, apiKey: key, model: (0, llm_1.getDefaultModel)(provider) });
+                }
+            }
+        }
+    }
+    // Also check server keys if available
+    if (config?.apiKey) {
+        try {
+            const { fetchLlmKeys } = await Promise.resolve().then(() => __importStar(require('../lib/api')));
+            const serverKeys = await fetchLlmKeys(config);
+            for (const serverKey of serverKeys) {
+                if (!seen.has(serverKey.provider)) {
+                    seen.add(serverKey.provider);
+                    providers.push({
+                        provider: serverKey.provider,
+                        apiKey: serverKey.api_key,
+                        model: serverKey.model || (0, llm_1.getDefaultModel)(serverKey.provider),
+                    });
+                }
+            }
+        }
+        catch {
+            // Server fetch failed, continue with what we have
+        }
+    }
+    return providers;
+}
 async function executePromptLocally(agentData, inputData, skillPrompts = [], config, providerOverride) {
     // If provider override specified, validate and use only that provider
     if (providerOverride) {
@@ -243,6 +295,44 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
     const providersToCheck = providerOverride
         ? [providerOverride]
         : agentData.supported_providers;
+    // Combine skill prompts with agent prompt (skills first, then agent)
+    let basePrompt = agentData.prompt || '';
+    if (skillPrompts.length > 0) {
+        basePrompt = [...skillPrompts, basePrompt].join('\n\n---\n\n');
+    }
+    // Build the prompt with input data (matches server behavior)
+    const prompt = (0, llm_1.buildPrompt)(basePrompt, inputData);
+    // When no provider override, detect all available providers for fallback support
+    if (!providerOverride) {
+        const allProviders = await detectAllLlmKeys(providersToCheck, config);
+        if (allProviders.length === 0) {
+            const providers = providersToCheck.join(', ');
+            throw new errors_1.CliError(`No LLM key found for: ${providers}\n` +
+                `Set an environment variable (e.g., OPENAI_API_KEY) or configure in web dashboard`);
+        }
+        // Apply agent default models to each provider config
+        const providersWithModels = allProviders.map((p) => ({
+            ...p,
+            model: agentData.default_models?.[p.provider] || p.model,
+        }));
+        // Show which provider is being used (primary)
+        const primary = providersWithModels[0];
+        if (providersWithModels.length > 1) {
+            process.stderr.write(`Running with ${primary.provider} (${primary.model}), ` +
+                `${providersWithModels.length - 1} fallback(s) available...\n`);
+        }
+        else {
+            process.stderr.write(`Running with ${primary.provider} (${primary.model})...\n`);
+        }
+        // Use fallback if multiple providers, otherwise single call
+        if (providersWithModels.length > 1) {
+            return await (0, llm_1.callLlmWithFallback)(providersWithModels, prompt, agentData.output_schema);
+        }
+        else {
+            return await (0, llm_1.callLlm)(primary.provider, primary.apiKey, primary.model, prompt, agentData.output_schema);
+        }
+    }
+    // Provider override: use single provider (existing behavior)
     const detected = await (0, llm_1.detectLlmKey)(providersToCheck, config);
     if (!detected) {
         const providers = providersToCheck.join(', ');
@@ -254,13 +344,6 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
     const model = serverModel || agentData.default_models?.[provider] || (0, llm_1.getDefaultModel)(provider);
     // Show which provider is being used (helpful for debugging rate limits)
     process.stderr.write(`Running with ${provider} (${model})...\n`);
-    // Combine skill prompts with agent prompt (skills first, then agent)
-    let basePrompt = agentData.prompt || '';
-    if (skillPrompts.length > 0) {
-        basePrompt = [...skillPrompts, basePrompt].join('\n\n---\n\n');
-    }
-    // Build the prompt with input data (matches server behavior)
-    const prompt = (0, llm_1.buildPrompt)(basePrompt, inputData);
     // Call the LLM directly
     const response = await (0, llm_1.callLlm)(provider, key, model, prompt, agentData.output_schema);
     return response;

package/dist/commands/skill.js

@@ -162,8 +162,29 @@ Instructions and guidance for AI agents...
         .description('Install skill to local AI tool directories (Claude Code, Cursor, etc.)')
         .option('--global', 'Install to home directory (default: current directory)')
         .option('--dry-run', 'Show what would be installed without making changes')
+        .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
         .action(async (skillRef, options) => {
         const resolved = await (0, config_1.getResolvedConfig)();
+        // Determine target formats
+        let targetFormats = [];
+        if (options.format) {
+            targetFormats = options.format.split(',').map((f) => f.trim());
+            // Validate format IDs
+            const invalid = targetFormats.filter(f => !config_1.VALID_FORMAT_IDS.includes(f));
+            if (invalid.length > 0) {
+                throw new errors_1.CliError(`Invalid format ID(s): ${invalid.join(', ')}. Valid: ${config_1.VALID_FORMAT_IDS.join(', ')}`);
+            }
+        }
+        else {
+            const defaults = await (0, config_1.getDefaultFormats)();
+            if (defaults.length > 0) {
+                targetFormats = defaults;
+            }
+        }
+        // Determine target directories
+        const toolDirs = targetFormats.length > 0
+            ? targetFormats.map(f => config_1.FORMAT_SKILL_DIRS[f])
+            : AI_TOOL_SKILL_DIRS; // fallback to all
         const parsed = parseSkillRef(skillRef);
         const org = parsed.org ?? resolved.defaultOrg;
         if (!org) {
@@ -191,7 +212,7 @@ ${skillData.prompt}
         if (options.dryRun) {
             process.stdout.write(`Would install ${org}/${parsed.skill}@${parsed.version}\n\n`);
             process.stdout.write(`Target directories:\n`);
-            for (const tool of AI_TOOL_SKILL_DIRS) {
+            for (const tool of toolDirs) {
                 const skillDir = path_1.default.join(baseDir, tool.path);
                 const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
                 process.stdout.write(`  - ${tool.name}: ${skillFile}\n`);
@@ -199,9 +220,9 @@ ${skillData.prompt}
             process.stdout.write(`\nNo changes made (dry run)\n`);
             return;
         }
-        // Install to all AI tool directories
+        // Install to target AI tool directories
         const installed = [];
-        for (const tool of AI_TOOL_SKILL_DIRS) {
+        for (const tool of toolDirs) {
             const skillDir = path_1.default.join(baseDir, tool.path);
             const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
             try {

package/dist/commands/update.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpdateCommand = registerUpdateCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const analytics_1 = require("../lib/analytics");
+const adapters_1 = require("../adapters");
+const installed_1 = require("../lib/installed");
+async function fetchLatestAgent(config, agentRef) {
+    const [org, name] = agentRef.split('/');
+    if (!org || !name)
+        return null;
+    try {
+        // Try to get latest version
+        const agent = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/latest`);
+        return {
+            agent: { ...agent, org_slug: org },
+            latestVersion: agent.version
+        };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 404) {
+            return null;
+        }
+        throw err;
+    }
+}
+function registerUpdateCommand(program) {
+    program
+        .command('update [agent]')
+        .description('Update installed agents to latest versions')
+        .option('--check', 'Check for updates without installing')
+        .option('--force', 'Force update even if file was modified locally')
+        .action(async (agentRef, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const installed = await (0, installed_1.getInstalled)();
+        if (installed.length === 0) {
+            process.stdout.write('No agents installed. Use "orch install <agent>" to install agents.\n');
+            return;
+        }
+        // Filter to specific agent if provided
+        const toCheck = agentRef
+            ? installed.filter(i => i.agent === agentRef)
+            : installed;
+        if (toCheck.length === 0) {
+            process.stdout.write(`Agent "${agentRef}" is not installed.\n`);
+            return;
+        }
+        process.stdout.write(`Checking ${toCheck.length} installed agent(s) for updates...\n\n`);
+        let updatesAvailable = 0;
+        let updatesApplied = 0;
+        let skippedModified = 0;
+        for (const item of toCheck) {
+            // Check if file was modified locally
+            const wasModified = await (0, installed_1.checkModified)(item);
+            // Fetch latest version
+            const latest = await fetchLatestAgent(resolved, item.agent);
+            if (!latest) {
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${item.agent} - could not fetch latest\n`);
+                continue;
+            }
+            const hasUpdate = latest.latestVersion !== item.version;
+            if (!hasUpdate && !wasModified) {
+                process.stdout.write(`  ${chalk_1.default.green('✓')} ${item.agent}@${item.version} - up to date\n`);
+                continue;
+            }
+            if (wasModified && !options.force) {
+                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${item.agent} - local modifications (use --force to overwrite)\n`);
+                skippedModified++;
+                continue;
+            }
+            if (hasUpdate) {
+                updatesAvailable++;
+                process.stdout.write(`  ${chalk_1.default.blue('↑')} ${item.agent}@${item.version} → ${latest.latestVersion}`);
+                if (wasModified) {
+                    process.stdout.write(` ${chalk_1.default.yellow('(modified)')}`);
+                }
+                process.stdout.write('\n');
+                if (options.check) {
+                    continue;
+                }
+                // Apply update
+                const adapter = adapters_1.adapterRegistry.get(item.format);
+                if (!adapter) {
+                    process.stderr.write(`    Skipped: Unknown format "${item.format}"\n`);
+                    continue;
+                }
+                const checkResult = adapter.canConvert(latest.agent);
+                if (!checkResult.canConvert) {
+                    process.stderr.write(`    Skipped: ${checkResult.errors.join(', ')}\n`);
+                    continue;
+                }
+                const files = adapter.convert(latest.agent);
+                for (const file of files) {
+                    // Use the original path from tracking
+                    const fullPath = item.path;
+                    try {
+                        const dir = path_1.default.dirname(fullPath);
+                        await promises_1.default.mkdir(dir, { recursive: true });
+                        await promises_1.default.writeFile(fullPath, file.content);
+                        // Update tracking
+                        const updatedItem = {
+                            ...item,
+                            version: latest.latestVersion,
+                            installedAt: new Date().toISOString(),
+                            adapterVersion: adapter.version,
+                            contentHash: (0, installed_1.computeHash)(file.content),
+                        };
+                        await (0, installed_1.trackInstall)(updatedItem);
+                        process.stdout.write(`    Updated: ${fullPath}\n`);
+                        updatesApplied++;
+                    }
+                    catch (err) {
+                        process.stderr.write(`    Error: ${err.message}\n`);
+                    }
+                }
+            }
+        }
+        process.stdout.write('\n');
+        if (options.check) {
+            process.stdout.write(`Found ${updatesAvailable} update(s) available.\n`);
+            if (skippedModified > 0) {
+                process.stdout.write(`${skippedModified} agent(s) have local modifications.\n`);
+            }
+            process.stdout.write('Run "orch update" without --check to apply updates.\n');
+        }
+        else {
+            process.stdout.write(`Applied ${updatesApplied} update(s).\n`);
+            if (skippedModified > 0) {
+                process.stdout.write(`Skipped ${skippedModified} modified agent(s). Use --force to overwrite.\n`);
+            }
+        }
+        await (0, analytics_1.track)('cli_agent_update', {
+            checked: toCheck.length,
+            updatesAvailable,
+            updatesApplied,
+            skippedModified,
+        });
+    });
+}

package/dist/lib/api.js

@@ -59,6 +59,8 @@ exports.previewAgentVersion = previewAgentVersion;
 exports.reportInstall = reportInstall;
 const errors_1 = require("./errors");
 const DEFAULT_TIMEOUT_MS = 15000;
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
 async function safeFetch(url, options) {
     try {
         return await fetch(url, {
@@ -74,6 +76,39 @@ async function safeFetch(url, options) {
         throw new errors_1.NetworkError(url, err instanceof Error ? err : undefined);
     }
 }
+async function safeFetchWithRetry(url, options) {
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const response = await safeFetch(url, options);
+            // Don't retry client errors (except 429)
+            if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                return response;
+            }
+            // Retry on 5xx or 429
+            if (response.status >= 500 || response.status === 429) {
+                if (attempt < MAX_RETRIES) {
+                    const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                    const jitter = Math.random() * 500;
+                    process.stderr.write(`Request failed (${response.status}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                    await new Promise(r => setTimeout(r, delay + jitter));
+                    continue;
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < MAX_RETRIES) {
+                const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                const jitter = Math.random() * 500;
+                process.stderr.write(`Network error, retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                await new Promise(r => setTimeout(r, delay + jitter));
+            }
+        }
+    }
+    throw lastError ?? new errors_1.NetworkError(url);
+}
 class ApiError extends Error {
     status;
     payload;
@@ -108,7 +143,7 @@ async function request(config, method, path, options = {}) {
     if (!config.apiKey) {
         throw new ApiError('Missing API key. Run `orchagent login` first.', 401);
     }
-    const response = await safeFetch(buildUrl(config.apiUrl, path), {
+    const response = await safeFetchWithRetry(buildUrl(config.apiUrl, path), {
         method,
         headers: {
             Authorization: `Bearer ${config.apiKey}`,
@@ -122,7 +157,7 @@ async function request(config, method, path, options = {}) {
     return (await response.json());
 }
 async function publicRequest(config, path) {
-    const response = await safeFetch(buildUrl(config.apiUrl, path));
+    const response = await safeFetchWithRetry(buildUrl(config.apiUrl, path));
     if (!response.ok) {
         throw await parseError(response);
     }

package/dist/lib/config.js

@@ -3,16 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_SKILL_DIRS = exports.VALID_FORMAT_IDS = void 0;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.getResolvedConfig = getResolvedConfig;
 exports.getConfigPath = getConfigPath;
+exports.getDefaultFormats = getDefaultFormats;
+exports.setDefaultFormats = setDefaultFormats;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
 const CONFIG_PATH = path_1.default.join(CONFIG_DIR, 'config.json');
 const DEFAULT_API_URL = 'https://api.orchagent.io';
+// Valid format IDs for multi-format agent export
+exports.VALID_FORMAT_IDS = ['claude-code', 'cursor', 'codex', 'amp', 'opencode', 'antigravity'];
+// Map format IDs to skill directories (used by skill install and agent install)
+exports.FORMAT_SKILL_DIRS = {
+    'claude-code': { name: 'Claude Code', path: '.claude/skills' },
+    'cursor': { name: 'Cursor', path: '.cursor/skills' },
+    'codex': { name: 'Codex', path: '.codex/skills' },
+    'amp': { name: 'Amp', path: '.agents/skills' },
+    'opencode': { name: 'OpenCode', path: '.opencode/skill' },
+    'antigravity': { name: 'Antigravity', path: '.agent/skills' },
+};
 async function loadConfig() {
     try {
         const raw = await promises_1.default.readFile(CONFIG_PATH, 'utf-8');
@@ -56,3 +70,12 @@ async function getResolvedConfig(overrides = {}, profile) {
 function getConfigPath() {
     return CONFIG_PATH;
 }
+async function getDefaultFormats() {
+    const config = await loadConfig();
+    return config.default_formats ?? [];
+}
+async function setDefaultFormats(formats) {
+    const config = await loadConfig();
+    config.default_formats = formats;
+    await saveConfig(config);
+}

package/dist/lib/installed.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHash = computeHash;
+exports.loadInstalled = loadInstalled;
+exports.saveInstalled = saveInstalled;
+exports.trackInstall = trackInstall;
+exports.getInstalled = getInstalled;
+exports.getInstalledByFormat = getInstalledByFormat;
+exports.checkModified = checkModified;
+exports.untrackInstall = untrackInstall;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const ORCHAGENT_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const INSTALLED_PATH = path_1.default.join(ORCHAGENT_DIR, 'installed.json');
+/**
+ * Compute SHA-256 hash of content
+ */
+function computeHash(content) {
+    return crypto_1.default.createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Load installed agents from tracking file
+ */
+async function loadInstalled() {
+    try {
+        const raw = await promises_1.default.readFile(INSTALLED_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return { version: 1, installed: [] };
+        }
+        throw err;
+    }
+}
+/**
+ * Save installed agents to tracking file
+ */
+async function saveInstalled(data) {
+    await promises_1.default.mkdir(ORCHAGENT_DIR, { recursive: true });
+    await promises_1.default.writeFile(INSTALLED_PATH, JSON.stringify(data, null, 2) + '\n');
+}
+/**
+ * Track a newly installed agent
+ */
+async function trackInstall(agent) {
+    const data = await loadInstalled();
+    // Remove any existing entry for same agent/format/scope/path
+    data.installed = data.installed.filter(i => !(i.agent === agent.agent && i.format === agent.format && i.path === agent.path));
+    // Add new entry
+    data.installed.push(agent);
+    await saveInstalled(data);
+}
+/**
+ * Get all installed agents
+ */
+async function getInstalled() {
+    const data = await loadInstalled();
+    return data.installed;
+}
+/**
+ * Get installed agents filtered by format
+ */
+async function getInstalledByFormat(format) {
+    const data = await loadInstalled();
+    return data.installed.filter(i => i.format === format);
+}
+/**
+ * Check if a file has been modified since installation
+ */
+async function checkModified(installed) {
+    try {
+        const content = await promises_1.default.readFile(installed.path, 'utf-8');
+        const currentHash = computeHash(content);
+        return currentHash !== installed.contentHash;
+    }
+    catch {
+        // File doesn't exist or can't be read
+        return true;
+    }
+}
+/**
+ * Remove an installed agent from tracking
+ */
+async function untrackInstall(agentRef, format, filePath) {
+    const data = await loadInstalled();
+    data.installed = data.installed.filter(i => !(i.agent === agentRef && i.format === format && i.path === filePath));
+    await saveInstalled(data);
+}

package/dist/lib/llm.js

@@ -39,15 +39,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MODELS = exports.PROVIDER_ENV_VARS = void 0;
+exports.DEFAULT_MODELS = exports.PROVIDER_ENV_VARS = exports.LlmError = void 0;
+exports.isRateLimitError = isRateLimitError;
 exports.detectLlmKeyFromEnv = detectLlmKeyFromEnv;
 exports.detectLlmKey = detectLlmKey;
 exports.getDefaultModel = getDefaultModel;
 exports.buildPrompt = buildPrompt;
 exports.callLlm = callLlm;
+exports.callLlmWithFallback = callLlmWithFallback;
 exports.validateProvider = validateProvider;
 const errors_1 = require("./errors");
 const llm_errors_1 = require("./llm-errors");
+class LlmError extends errors_1.CliError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.LlmError = LlmError;
+function isRateLimitError(error) {
+    return error instanceof LlmError && error.statusCode === 429;
+}
 // Environment variable names for each provider
 exports.PROVIDER_ENV_VARS = {
     openai: 'OPENAI_API_KEY',
@@ -169,6 +182,27 @@ async function callLlm(provider, apiKey, model, prompt, outputSchema) {
     }
     throw new errors_1.CliError(`Unsupported provider: ${provider}`);
 }
+/**
+ * Call LLM with automatic fallback to next provider on rate limit.
+ * Tries each provider in order until one succeeds.
+ */
+async function callLlmWithFallback(providers, prompt, outputSchema) {
+    let lastError;
+    for (const { provider, apiKey, model } of providers) {
+        try {
+            return await callLlm(provider, apiKey, model, prompt, outputSchema);
+        }
+        catch (error) {
+            lastError = error;
+            if (isRateLimitError(error)) {
+                process.stderr.write(`${provider} rate-limited, trying next provider...\n`);
+                continue;
+            }
+            throw error; // Don't retry non-rate-limit errors
+        }
+    }
+    throw lastError ?? new errors_1.CliError('All LLM providers failed');
+}
 async function callOpenAI(apiKey, model, prompt, outputSchema) {
     const body = {
         model,
@@ -187,7 +221,8 @@ async function callOpenAI(apiKey, model, prompt, outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('openai', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('openai', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.choices?.[0]?.message?.content || '';
@@ -214,7 +249,8 @@ async function callAnthropic(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('anthropic', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('anthropic', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.content?.[0]?.text || '';
@@ -236,7 +272,8 @@ async function callGemini(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('gemini', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('gemini', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
@@ -264,10 +301,11 @@ async function callOllama(endpoint, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         if (response.status === 404) {
-            throw new errors_1.CliError(`Model '${model}' not found. Run: ollama pull ${model}`);
+            throw new LlmError(`Model '${model}' not found. Run: ollama pull ${model}`, 404);
         }
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('ollama', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('ollama', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = await response.json();
     const content = data.choices?.[0]?.message?.content || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.25",
+  "version": "0.3.0",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",