orchid-ai 1.2.2 → 1.2.4

package/dist/server/index.esm.js

@@ -1,7 +1,9 @@
 import express from 'express';
 import http from 'http';
-import path$a from 'path';
-import fs$8 from 'fs';
+import * as path$a from 'path';
+import path__default from 'path';
+import * as fs$8 from 'fs';
+import fs__default from 'fs';
 import require$$0 from 'os';
 import require$$0$1 from 'util';
 import require$$0$2 from 'stream';
@@ -79,7 +81,7 @@ var path$9 = {};
 Object.defineProperty(path$9, "__esModule", { value: true });
 path$9.convertPosixPathToPattern = path$9.convertWindowsPathToPattern = path$9.convertPathToPattern = path$9.escapePosixPath = path$9.escapeWindowsPath = path$9.escape = path$9.removeLeadingDotSegment = path$9.makeAbsolute = path$9.unixify = void 0;
 const os = require$$0;
-const path$8 = path$a;
+const path$8 = path__default;
 const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
 const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 /**
@@ -319,7 +321,7 @@ var isGlob$1 = function isGlob(str, options) {
 };
 
 var isGlob = isGlob$1;
-var pathPosixDirname = path$a.posix.dirname;
+var pathPosixDirname = path__default.posix.dirname;
 var isWin32 = require$$0.platform() === 'win32';
 
 var slash = '/';
@@ -1758,7 +1760,7 @@ var braces_1 = braces$1;
 
 var utils$f = {};
 
-const path$7 = path$a;
+const path$7 = path__default;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1938,7 +1940,7 @@ var constants$3 = {
 
 (function (exports) {
 
-	const path = path$a;
+	const path = path__default;
 	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
@@ -3482,7 +3484,7 @@ parse$1.fastpaths = (input, options) => {
 
 var parse_1 = parse$1;
 
-const path$6 = path$a;
+const path$6 = path__default;
 const scan = scan_1;
 const parse = parse_1;
 const utils$c = utils$f;
@@ -4300,7 +4302,7 @@ var micromatch_1 = micromatch$1;
 
 Object.defineProperty(pattern$1, "__esModule", { value: true });
 pattern$1.isAbsolute = pattern$1.partitionAbsoluteAndRelative = pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
-const path$5 = path$a;
+const path$5 = path__default;
 const globParent = globParent$1;
 const micromatch = micromatch_1;
 const GLOBSTAR = '**';
@@ -4893,7 +4895,7 @@ var fs$5 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = fs$8;
+	const fs = fs__default;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5244,7 +5246,7 @@ var fs$1 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = fs$8;
+	const fs = fs__default;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5263,7 +5265,7 @@ var fs$1 = {};
 } (fs$1));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$3 = path$a;
+const path$3 = path__default;
 const fsStat$3 = out$1;
 const fs = fs$1;
 let Settings$1 = class Settings {
@@ -5947,7 +5949,7 @@ sync$3.default = SyncProvider;
 var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$2 = path$a;
+const path$2 = path__default;
 const fsScandir = out$2;
 class Settings {
     constructor(_options = {}) {
@@ -6009,7 +6011,7 @@ function getSettings(settingsOrOptions = {}) {
 var reader = {};
 
 Object.defineProperty(reader, "__esModule", { value: true });
-const path$1 = path$a;
+const path$1 = path__default;
 const fsStat$2 = out$1;
 const utils$6 = utils$k;
 class Reader {
@@ -6419,7 +6421,7 @@ class EntryTransformer {
 entry.default = EntryTransformer;
 
 Object.defineProperty(provider, "__esModule", { value: true });
-const path = path$a;
+const path = path__default;
 const deep_1 = deep;
 const entry_1 = entry$1;
 const error_1 = error;
@@ -6597,7 +6599,7 @@ var settings = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = fs$8;
+	const fs = fs__default;
 	const os = require$$0;
 	/**
 	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
@@ -6759,7 +6761,7 @@ var fg = /*@__PURE__*/getDefaultExportFromCjs(out);
 
 const DEFAULT_CONFIG = {
     service: 'claude',
-    model: 'claude-sonnet-4-20250514',
+    model: 'claude-sonnet-4-5-20250929', // Updated to use newer 4.5 model
     temperature: 0.7,
     maxTokens: 4096,
     chatLevel: 'none',
@@ -7156,7 +7158,7 @@ const noneChatInstructions = genericInstructions +
       "action": "Create John Smith",
       "actionType": "create",
       "path": "/users/add",
-      "formState": {"name": "John Smith", "email": "john@example.com", "role": "user"}
+      "formState": {"firstName": "John", "lastName": "Smith", "email": "john@example.com", "role": "user"}
     }
   ]
 
@@ -7583,7 +7585,7 @@ class CommandTrainingCollector {
                     if (files.length > 0) {
                         this.log(`✅ Found ${files.length} ${type}:`);
                         files.forEach((file) => {
-                            this.log(`   📄 ${path$a.relative(this.rootDir, file.filePath)}`);
+                            this.log(`   📄 ${path__default.relative(this.rootDir, file.filePath)}`);
                         });
                     }
                     else {
@@ -7818,9 +7820,9 @@ class CommandTrainingCollector {
         const results = await Promise.all(expandedPaths.map(async (filePath) => {
             try {
                 // Read and process the file
-                const content = await fs$8.promises.readFile(filePath, 'utf8');
+                const content = await fs__default.promises.readFile(filePath, 'utf8');
                 const extractedInfo = this.extractFileInfo(fieldName, content);
-                const relativePath = path$a.relative(this.rootDir, filePath);
+                const relativePath = path__default.relative(this.rootDir, filePath);
                 // Log what we found in the file
                 const foundItems = Object.keys(extractedInfo).length;
                 if (foundItems > 0) {
@@ -7855,8 +7857,8 @@ class CommandTrainingCollector {
         for (const pattern of patterns) {
             try {
                 // Check if it's a direct file path first
-                const fullPath = path$a.join(this.rootDir, pattern);
-                const exists = await fs$8.promises
+                const fullPath = path__default.join(this.rootDir, pattern);
+                const exists = await fs__default.promises
                     .access(fullPath)
                     .then(() => true)
                     .catch(() => false);
@@ -7875,7 +7877,7 @@ class CommandTrainingCollector {
                     });
                     if (matches.length > 0) {
                         this.log(`✅ Found ${matches.length} files matching pattern: ${pattern}`);
-                        matches.forEach((match) => this.log(`   - ${path$a.relative(this.rootDir, match)}`));
+                        matches.forEach((match) => this.log(`   - ${path__default.relative(this.rootDir, match)}`));
                     }
                     else {
                         this.log(`⚠️  No files found matching pattern: ${pattern}`);
@@ -8348,20 +8350,35 @@ function getModelSupportsImages(modelId, provider) {
         openai: {
             'gpt-4o': true,
             'gpt-4o-mini': true,
-            'gpt-4-vision-preview': true,
             'gpt-4-turbo': true,
             'gpt-4-turbo-2024-04-09': true,
+            'gpt-4-turbo-preview': true,
+            'gpt-4-vision-preview': true,
+            'gpt-4-0125-preview': true,
+            'gpt-4-1106-preview': true,
+            'gpt-5-nano-2025-08-07': false, // Note: add when known
+            'gpt-5-search-api-2025-10-14': false, // Note: add when known
+            'gpt-4o-transcribe-diarize': false, // Audio model, not images
             'gpt-3.5-turbo': false,
             'gpt-4': false,
+            'gpt-4-0613': false,
         },
-        // Claude models - all Claude 3+ models support images
+        // Claude models - all Claude 3+ and 4+ models support images
         claude: {
+            // Claude 3.x models
             'claude-3-haiku-20240307': true,
             'claude-3-sonnet-20240229': true,
             'claude-3-opus-20240229': true,
             'claude-3-5-haiku-20241022': true,
             'claude-3-5-sonnet-20241022': true,
             'claude-3-7-sonnet-20250219': true,
+            // Claude 4.x models (newer naming)
+            'claude-opus-4-20250514': true,
+            'claude-opus-4-1-20250805': true,
+            'claude-sonnet-4-20250514': true,
+            'claude-sonnet-4-5-20250929': true,
+            'claude-haiku-4-5-20251001': true,
+            // Claude 2.x and older - no image support
             'claude-2.1': false,
             'claude-2.0': false,
             'claude-instant-1.2': false,
@@ -8371,6 +8388,10 @@ function getModelSupportsImages(modelId, provider) {
             'gemini-1.5-flash': true,
             'gemini-1.5-pro': true,
             'gemini-2.0-flash-exp': true,
+            'gemini-2.0-flash-thinking-exp-1219': true,
+            'gemini-2.5-pro': true,
+            'gemini-2.5-flash': true,
+            'gemini-2.5-flash-lite': true,
             'gemini-pro': false,
             'gemini-pro-vision': true,
         },
@@ -8382,9 +8403,16 @@ function getModelSupportsImages(modelId, provider) {
     if (modelId in providerSupport) {
         return providerSupport[modelId];
     }
-    // For Claude models, assume true if it's a claude-3+ model
-    if (provider?.toLowerCase() === 'claude' && modelId.startsWith('claude-3')) {
-        return true;
+    // For Claude models, assume true if it's a claude-3+ or claude-4+ model
+    // Also handle claude-sonnet-4, claude-opus-4, claude-haiku-4 pattern
+    if (provider?.toLowerCase() === 'claude') {
+        if (modelId.startsWith('claude-3') || modelId.startsWith('claude-4')) {
+            return true;
+        }
+        // Handle newer naming like claude-sonnet-4, claude-opus-4, claude-haiku-4
+        if (modelId.match(/claude-(?:sonnet|opus|haiku)-\d/)) {
+            return true;
+        }
     }
     // For OpenAI, assume false unless explicitly listed
     if (provider?.toLowerCase() === 'openai') {
@@ -8397,6 +8425,32 @@ function getModelSupportsImages(modelId, provider) {
     return false;
 }
 function getDefaultModelsForProvider(provider) {
+    // Try to get from cache first
+    try {
+        // Dynamic import to avoid circular dependency
+        const { ContextualCommandService } = require('./contextual-service.js');
+        const cachedModels = ContextualCommandService.getCachedModelsSync();
+        if (cachedModels && cachedModels.length > 0) {
+            const providerModels = cachedModels.filter((m) => m.provider.toLowerCase() === provider.toLowerCase());
+            if (providerModels.length > 0) {
+                // Sort by computeWeight (lowest = cheapest/fastest first)
+                const sorted = providerModels.sort((a, b) => (a.computeWeight ?? 0.5) - (b.computeWeight ?? 0.5));
+                // Return top 3 models for the provider
+                return sorted.slice(0, 3).map((model) => ({
+                    id: model.id,
+                    name: model.name,
+                    provider: model.provider,
+                    available: model.available,
+                    supportsImages: model.supportsImages ?? getModelSupportsImages(model.id, model.provider),
+                    computeWeight: model.computeWeight,
+                }));
+            }
+        }
+    }
+    catch (error) {
+        // Silently fall through to defaults
+    }
+    // Fallback to hardcoded defaults if cache unavailable
     const defaultModels = {
         openai: [
             {
@@ -8416,18 +8470,18 @@ function getDefaultModelsForProvider(provider) {
         ],
         claude: [
             {
-                id: 'claude-3-5-haiku-20241022',
-                name: 'Claude 3.5 Haiku',
+                id: 'claude-haiku-4-5-20251001',
+                name: 'Claude 4.5 Haiku',
                 provider: 'claude',
                 available: true,
-                supportsImages: getModelSupportsImages('claude-3-5-haiku-20241022', 'claude'),
+                supportsImages: getModelSupportsImages('claude-haiku-4-5-20251001', 'claude'),
             },
             {
-                id: 'claude-3-7-sonnet-20250219',
-                name: 'Claude 3.7 Sonnet',
+                id: 'claude-sonnet-4-5-20250929',
+                name: 'Claude 4.5 Sonnet',
                 provider: 'claude',
                 available: true,
-                supportsImages: getModelSupportsImages('claude-3-7-sonnet-20250219', 'claude'),
+                supportsImages: getModelSupportsImages('claude-sonnet-4-5-20250929', 'claude'),
             },
         ],
         gemini: [
@@ -10207,7 +10261,7 @@ class CommandService {
             // Default models for each provider
             const defaultModels = {
                 openai: ['gpt-3.5-turbo', 'gpt-4'],
-                claude: ['claude-3-opus-20240229', 'claude-3-sonnet-20240229'],
+                claude: ['claude-haiku-4-5-20251001', 'claude-sonnet-4-5-20250929'],
                 gemini: ['gemini-pro'],
             };
             // Configure each provider that has an API key
@@ -10383,8 +10437,8 @@ class CommandService {
                 return;
             }
             // Write to file
-            const configPath = path$a.join(process.cwd(), 'ai-command-config.json');
-            await fs$8.promises.writeFile(configPath, JSON.stringify(configToWrite, null, 2), 'utf8');
+            const configPath = path__default.join(process.cwd(), 'ai-command-config.json');
+            await fs__default.promises.writeFile(configPath, JSON.stringify(configToWrite, null, 2), 'utf8');
             this.log(`✅ CommandService: Config written to file: ${configPath}`);
         }
         catch (error) {
@@ -10394,7 +10448,7 @@ class CommandService {
     async writeFailedJsonToFile(failedJson, errorMessage) {
         try {
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-            const debugPath = path$a.join(process.cwd(), `failed-json-${timestamp}.json`);
+            const debugPath = path__default.join(process.cwd(), `failed-json-${timestamp}.json`);
             const debugData = {
                 timestamp: new Date().toISOString(),
                 error: errorMessage,
@@ -10403,7 +10457,7 @@ class CommandService {
                 // Also include a prettified version for easier reading
                 prettyJson: this.tryPrettifyJson(failedJson),
             };
-            await fs$8.promises.writeFile(debugPath, JSON.stringify(debugData, null, 2));
+            await fs__default.promises.writeFile(debugPath, JSON.stringify(debugData, null, 2));
             this.log('📁 Failed JSON written to file:', debugPath);
         }
         catch (error) {
@@ -12729,22 +12783,24 @@ async function setupCommandServer(options = {}) {
     // Create the command configuration
     // Build providers configuration with all available API keys
     const availableProviders = {};
+    // These model lists are just placeholders - the actual models will be auto-discovered
+    // from the provider APIs and cached. The models here are only used for legacy compatibility.
     if (openaiApiKey) {
         availableProviders.openai = {
             apiKey: openaiApiKey,
-            models: ['gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo'],
+            models: [], // Models will be auto-discovered from API
         };
     }
     if (claudeApiKey) {
         availableProviders.claude = {
             apiKey: claudeApiKey,
-            models: ['claude-3-opus', 'claude-3-sonnet', 'claude-3-haiku'],
+            models: [], // Models will be auto-discovered from API
         };
     }
     if (geminiApiKey) {
         availableProviders.gemini = {
             apiKey: geminiApiKey,
-            models: ['gemini-pro', 'gemini-pro-vision'],
+            models: [], // Models will be auto-discovered from API
         };
     }
     // Add custom providers if provided
@@ -13239,6 +13295,9 @@ async function collectTrainingData(config) {
  */
 class ContextualCommandService {
     config;
+    modelsCache = null;
+    cacheFilePath;
+    CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
     verboseLogging;
     usage;
     constructor(config) {
@@ -13254,8 +13313,55 @@ class ContextualCommandService {
             currentProvider: '',
             currentModel: '',
         };
+        // Set up cache file path (store in node_modules/.cache or process.cwd())
+        const cacheDir = path$a.join(process.cwd(), '.cache', 'orchid-ai');
+        if (!fs$8.existsSync(cacheDir)) {
+            fs$8.mkdirSync(cacheDir, { recursive: true });
+        }
+        this.cacheFilePath = path$a.join(cacheDir, 'models-cache.json');
+        // Load cache on initialization
+        this.loadModelsCache();
         this.autoConfigureProviders();
     }
+    /**
+     * Load models cache from file if it exists and is fresh
+     */
+    loadModelsCache() {
+        try {
+            if (fs$8.existsSync(this.cacheFilePath)) {
+                const cacheData = fs$8.readFileSync(this.cacheFilePath, 'utf8');
+                const cache = JSON.parse(cacheData);
+                const age = Date.now() - cache.timestamp;
+                if (age < this.CACHE_TTL_MS) {
+                    this.modelsCache = cache;
+                    this.log(`📦 Loaded models cache (age: ${Math.round(age / 1000 / 60)} minutes, ${cache.models.length} models)`);
+                }
+                else {
+                    this.log(`⏰ Models cache expired (age: ${Math.round(age / 1000 / 60 / 60)} hours), will refresh`);
+                }
+            }
+        }
+        catch (error) {
+            this.log('⚠️ Could not load models cache:', error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Save models cache to file
+     */
+    saveModelsCache(models) {
+        try {
+            const cache = {
+                timestamp: Date.now(),
+                models,
+            };
+            fs$8.writeFileSync(this.cacheFilePath, JSON.stringify(cache, null, 2), 'utf8');
+            this.modelsCache = cache;
+            this.log(`💾 Saved models cache (${models.length} models) to ${this.cacheFilePath}`);
+        }
+        catch (error) {
+            this.log('⚠️ Could not save models cache:', error instanceof Error ? error.message : String(error));
+        }
+    }
     autoConfigureProviders() {
         const apiKeys = {
             openai: this.config.openaiApiKey || process.env.OPENAI_API_KEY,
@@ -13479,8 +13585,6 @@ ${additionalContext}
 `;
         }
         const fullPrompt = `${baseInstructions}${schemaInstructions}${contextSection}`;
-        // Debug: Log the system prompt being sent to AI
-        this.log('🔍 [SYSTEM PROMPT DEBUG] Full system prompt:', fullPrompt);
         return fullPrompt;
     }
     /**
@@ -13551,14 +13655,48 @@ ${additionalContext}
     async streamSuggestions(request, onData, onDone, onError) {
         const { command, schema, chatHistory = [], modelSelection, chatLevel = this.config.chatLevel || 'none', additionalContext, images = [], } = request;
         try {
-            this.log('🚀 [CONTEXTUAL STREAM] Starting with schema:', schema?.title || 'none');
             // Create model for this request
-            const requestModel = modelSelection
-                ? this.createModelForRequest(modelSelection)
-                : this.createModelForRequest({
-                    provider: DEFAULT_CONFIG.service,
-                    model: DEFAULT_CONFIG.model,
-                });
+            let finalModelSelection = modelSelection;
+            if (!finalModelSelection) {
+                // Use tier-based default (fast/cheapest tier)
+                const defaultProvider = Object.keys(this.config.providers || {})[0] || DEFAULT_CONFIG.service;
+                this.log(`⚠️ [MODEL SELECTION] No modelSelection provided, using default provider: ${defaultProvider}`);
+                const defaultModel = await this.getDefaultModelByTier(defaultProvider, 'fast');
+                // Use dynamic default instead of hardcoded DEFAULT_CONFIG.model
+                const fallbackModel = defaultModel || await this.getLatestDefaultModel(defaultProvider);
+                finalModelSelection = {
+                    provider: defaultProvider,
+                    model: fallbackModel,
+                };
+                this.log(`📋 [MODEL SELECTION] Using default model for ${defaultProvider}: ${finalModelSelection.model}`);
+            }
+            else if (finalModelSelection.provider && !finalModelSelection.model) {
+                // Provider specified but no model - auto-select from tier
+                const tier = finalModelSelection.tier || 'fast';
+                const selectedModel = await this.getDefaultModelByTier(finalModelSelection.provider, tier);
+                if (!selectedModel) {
+                }
+                // Use dynamic default instead of hardcoded DEFAULT_CONFIG.model
+                const fallbackModel = selectedModel || await this.getLatestDefaultModel(finalModelSelection.provider);
+                finalModelSelection = {
+                    provider: finalModelSelection.provider,
+                    model: fallbackModel,
+                };
+            }
+            else if (finalModelSelection.model) {
+            }
+            // Ensure model is always defined before creating request model
+            if (!finalModelSelection.model) {
+                finalModelSelection.model = await this.getLatestDefaultModel(finalModelSelection.provider || DEFAULT_CONFIG.service);
+            }
+            // Ensure provider is also defined
+            if (!finalModelSelection.provider) {
+                finalModelSelection.provider = DEFAULT_CONFIG.service;
+            }
+            const requestModel = this.createModelForRequest({
+                provider: finalModelSelection.provider,
+                model: finalModelSelection.model,
+            });
             // Build system prompt with schema context
             const systemPrompt = this.buildContextualSystemPrompt(schema, chatLevel, additionalContext);
             // Build messages array
@@ -13919,12 +14057,37 @@ ${additionalContext}
         const { command, schema, chatHistory = [], modelSelection, chatLevel = this.config.chatLevel || 'none', additionalContext, } = request;
         try {
             // Create model for this request
-            const requestModel = modelSelection
-                ? this.createModelForRequest(modelSelection)
-                : this.createModelForRequest({
-                    provider: DEFAULT_CONFIG.service,
-                    model: DEFAULT_CONFIG.model,
-                });
+            let finalModelSelection = modelSelection;
+            if (!finalModelSelection) {
+                // Use tier-based default (fast/cheapest tier)
+                const defaultProvider = DEFAULT_CONFIG.service;
+                const defaultModel = await this.getDefaultModelByTier(defaultProvider, 'fast');
+                finalModelSelection = {
+                    provider: defaultProvider,
+                    model: defaultModel || DEFAULT_CONFIG.model,
+                };
+                this.log(`📋 Using default model for ${defaultProvider}: ${finalModelSelection.model}`);
+            }
+            else if (finalModelSelection.provider && !finalModelSelection.model) {
+                // Provider specified but no model - auto-select from tier
+                const tier = finalModelSelection.tier || 'fast';
+                const defaultModel = await this.getDefaultModelByTier(finalModelSelection.provider, tier);
+                finalModelSelection = {
+                    provider: finalModelSelection.provider,
+                    model: defaultModel || DEFAULT_CONFIG.model,
+                };
+                if (defaultModel) {
+                    this.log(`📋 Auto-selected ${tier} tier model for ${finalModelSelection.provider}: ${defaultModel}`);
+                }
+            }
+            // Ensure model is always defined before creating request model
+            if (!finalModelSelection.model) {
+                finalModelSelection.model = DEFAULT_CONFIG.model;
+            }
+            const requestModel = this.createModelForRequest({
+                provider: finalModelSelection.provider,
+                model: finalModelSelection.model,
+            });
             // Build system prompt
             const systemPrompt = this.buildContextualSystemPrompt(schema, chatLevel, additionalContext);
             // Build messages
@@ -13995,9 +14158,55 @@ ${additionalContext}
         }
     }
     /**
-     * Get available models
+     * Static utility to read cached models from file (for use in other services)
+     */
+    static getCachedModelsSync() {
+        try {
+            // Use the same cache location as instance method
+            const cacheDir = path$a.join(process.cwd(), '.cache', 'orchid-ai');
+            const cacheFilePath = path$a.join(cacheDir, 'models-cache.json');
+            if (!fs$8.existsSync(cacheFilePath)) {
+                return [];
+            }
+            const cacheContent = fs$8.readFileSync(cacheFilePath, 'utf8');
+            const cache = JSON.parse(cacheContent);
+            // Check if cache is still valid (24 hours)
+            const age = Date.now() - cache.timestamp;
+            const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+            if (age < CACHE_TTL_MS && cache.models && cache.models.length > 0) {
+                return cache.models;
+            }
+            return [];
+        }
+        catch (error) {
+            // Silently fail - return empty array
+            return [];
+        }
+    }
+    /**
+     * Static utility to get the fastest model for a provider from cache
+     */
+    static getFastestModelSync(provider) {
+        const cachedModels = this.getCachedModelsSync();
+        const providerModels = cachedModels
+            .filter(m => m.provider.toLowerCase() === provider.toLowerCase())
+            .sort((a, b) => (a.computeWeight ?? 0.5) - (b.computeWeight ?? 0.5));
+        return providerModels.length > 0 ? providerModels[0].id : null;
+    }
+    /**
+     * Get available models from API or use cached/defaults
+     * Uses file-based cache that refreshes every 24 hours
      */
     async getAvailableModels() {
+        // Check if we have a valid cache
+        if (this.modelsCache) {
+            const age = Date.now() - this.modelsCache.timestamp;
+            if (age < this.CACHE_TTL_MS) {
+                this.log(`📦 Using cached models (${this.modelsCache.models.length} models, ${Math.round(age / 1000 / 60)} minutes old)`);
+                return this.modelsCache.models;
+            }
+            this.log(`⏰ Cache expired (${Math.round(age / 1000 / 60 / 60)} hours old), fetching fresh models...`);
+        }
         try {
             const allModels = [];
             if (this.config.providers) {
@@ -14011,16 +14220,40 @@ ${additionalContext}
                             case 'claude':
                                 try {
                                     const claudeModels = await tempModel.models.list();
-                                    providerModels = claudeModels.data.map((model) => ({
-                                        id: model.id,
-                                        name: model.display_name || model.id,
-                                        provider: providerName,
-                                        available: true,
-                                    }));
+                                    providerModels = claudeModels.data
+                                        .filter((model) => model.id.includes('claude'))
+                                        .map((model) => {
+                                        // Determine compute weight based on model name (lower = cheaper)
+                                        // Check in priority order: haiku (cheapest), sonnet (medium), opus (most expensive)
+                                        let computeWeight = 0.5; // default balanced for unknown models
+                                        const modelIdLower = model.id.toLowerCase();
+                                        if (modelIdLower.includes('haiku')) {
+                                            computeWeight = 0.2; // Cheapest - Haiku models (e.g., claude-3-5-haiku-20241022)
+                                        }
+                                        else if (modelIdLower.includes('sonnet')) {
+                                            computeWeight = 0.6; // Medium cost - Sonnet models (e.g., claude-sonnet-4-20250514)
+                                        }
+                                        else if (modelIdLower.includes('opus')) {
+                                            computeWeight = 1.2; // Most expensive - Opus models (e.g., claude-opus-4-20250514)
+                                        }
+                                        // Note: Models not matching above patterns default to 0.5 (balanced)
+                                        // Auto-detect image support for this model
+                                        const supportsImages = getModelSupportsImages(model.id, providerName);
+                                        return {
+                                            id: model.id,
+                                            name: model.display_name || model.id,
+                                            provider: providerName,
+                                            available: true,
+                                            computeWeight,
+                                            supportsImages,
+                                        };
+                                    });
                                 }
                                 catch {
+                                    // Fallback defaults with image support
                                     providerModels = [
-                                        { id: 'claude-3-5-haiku-20241022', name: 'Claude 3.5 Haiku', provider: providerName, available: true },
+                                        { id: 'claude-3-5-haiku-20241022', name: 'Claude 3.5 Haiku', provider: providerName, available: true, computeWeight: 0.2, supportsImages: true },
+                                        { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet', provider: providerName, available: true, computeWeight: 0.6, supportsImages: true },
                                     ];
                                 }
                                 break;
@@ -14028,26 +14261,62 @@ ${additionalContext}
                                 try {
                                     const openaiModels = await tempModel.models.list();
                                     providerModels = openaiModels.data
-                                        .filter((model) => model.id.includes('gpt'))
-                                        .map((model) => ({
+                                        .filter((model) => model.id.includes('gpt') && !model.id.includes('instruct'))
+                                        .map((model) => {
+                                        // Determine compute weight
+                                        let computeWeight = 0.5;
+                                        if (model.id.includes('gpt-4-turbo') || model.id.includes('gpt-4o')) {
+                                            computeWeight = model.id.includes('mini') ? 0.3 : 1.0;
+                                        }
+                                        else if (model.id.includes('gpt-3.5')) {
+                                            computeWeight = 0.2;
+                                        }
+                                        // Auto-detect image support for this model
+                                        const supportsImages = getModelSupportsImages(model.id, providerName);
+                                        return {
+                                            id: model.id,
+                                            name: model.id,
+                                            provider: providerName,
+                                            available: true,
+                                            computeWeight,
+                                            supportsImages,
+                                        };
+                                    });
+                                }
+                                catch {
+                                    // Fallback defaults with image support
+                                    providerModels = [
+                                        { id: 'gpt-4o-mini', name: 'GPT-4o Mini', provider: providerName, available: true, computeWeight: 0.3, supportsImages: true },
+                                        { id: 'gpt-4o', name: 'GPT-4o', provider: providerName, available: true, computeWeight: 1.0, supportsImages: true },
+                                    ];
+                                }
+                                break;
+                            case 'gemini':
+                                try {
+                                    // Gemini models are statically defined as API doesn't provide list endpoint
+                                    // Auto-detect image support for each model
+                                    const geminiModelList = [
+                                        { id: 'gemini-2.0-flash-exp', name: 'Gemini 2.0 Flash Exp', computeWeight: 0.2 },
+                                        { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash', computeWeight: 0.2 },
+                                        { id: 'gemini-2.0-flash-thinking-exp-1219', name: 'Gemini 2.0 Flash Thinking', computeWeight: 0.5 },
+                                        { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro', computeWeight: 0.8 },
+                                        { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', computeWeight: 1.0 },
+                                    ];
+                                    providerModels = geminiModelList.map(model => ({
                                         id: model.id,
-                                        name: model.id,
+                                        name: model.name,
                                         provider: providerName,
                                         available: true,
+                                        computeWeight: model.computeWeight,
+                                        supportsImages: getModelSupportsImages(model.id, providerName),
                                     }));
                                 }
                                 catch {
                                     providerModels = [
-                                        { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo', provider: providerName, available: true },
-                                        { id: 'gpt-4o-mini', name: 'GPT-4O Mini', provider: providerName, available: true },
+                                        { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash', provider: providerName, available: true, computeWeight: 0.2, supportsImages: true },
                                     ];
                                 }
                                 break;
-                            case 'gemini':
-                                providerModels = [
-                                    { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash', provider: providerName, available: true },
-                                ];
-                                break;
                         }
                         allModels.push(...providerModels);
                     }
@@ -14056,13 +14325,120 @@ ${additionalContext}
                     }
                 }
             }
+            // Save to cache for future use
+            if (allModels.length > 0) {
+                this.saveModelsCache(allModels);
+            }
             return allModels;
         }
         catch (error) {
             this.handleError(error);
+            // If we have a stale cache, use it as fallback
+            if (this.modelsCache) {
+                this.log('⚠️ Failed to fetch models, using stale cache as fallback');
+                return this.modelsCache.models;
+            }
             return [];
         }
     }
+    /**
+     * Get the latest default model for a provider (balanced tier, or fallback to hardcoded)
+     * This should be used instead of DEFAULT_CONFIG.model when possible
+     */
+    async getLatestDefaultModel(provider = DEFAULT_CONFIG.service) {
+        try {
+            const balancedModel = await this.getDefaultModelByTier(provider, 'balanced');
+            if (balancedModel) {
+                return balancedModel;
+            }
+        }
+        catch (error) {
+            this.log(`⚠️ Could not get latest default model for ${provider}, using fallback`);
+        }
+        // Fallback to hardcoded defaults if dynamic lookup fails (using latest 4-5 models)
+        const fallbackDefaults = {
+            claude: 'claude-sonnet-4-5-20250929',
+            openai: 'gpt-4o',
+            gemini: 'gemini-2.0-flash-thinking-exp-1219',
+        };
+        return fallbackDefaults[provider.toLowerCase()] || DEFAULT_CONFIG.model;
+    }
+    /**
+     * Get default models by tier for a provider
+     * @param provider - Provider name
+     * @param tier - 'fast' (lowest computeWeight = cheapest), 'balanced' (medium), or 'powerful' (highest = most expensive)
+     */
+    async getDefaultModelByTier(provider, tier = 'fast') {
+        const availableModels = await this.getAvailableModels();
+        const providerModels = availableModels.filter((m) => m.provider.toLowerCase() === provider.toLowerCase());
+        if (providerModels.length === 0) {
+            this.log(`⚠️ [getDefaultModelByTier] No models found for provider ${provider}, using fallback`);
+            // Fallback to hardcoded defaults (using latest 4-5 models)
+            const defaults = {
+                claude: {
+                    fast: 'claude-haiku-4-5-20251001',
+                    balanced: 'claude-sonnet-4-5-20250929',
+                    powerful: 'claude-opus-4-20250514',
+                },
+                openai: {
+                    fast: 'gpt-4o-mini',
+                    balanced: 'gpt-4o',
+                    powerful: 'gpt-4-turbo',
+                },
+                gemini: {
+                    fast: 'gemini-1.5-flash',
+                    balanced: 'gemini-2.0-flash-thinking-exp-1219',
+                    powerful: 'gemini-2.5-pro',
+                },
+            };
+            const fallback = defaults[provider.toLowerCase()]?.[tier];
+            if (fallback) {
+                this.log(`⚠️ Using fallback model for ${provider} ${tier}: ${fallback}`);
+                return fallback;
+            }
+            return null;
+        }
+        // Sort by computeWeight (ascending - lowest weight = cheapest)
+        const sorted = providerModels.sort((a, b) => {
+            const weightA = a.computeWeight ?? 0.5;
+            const weightB = b.computeWeight ?? 0.5;
+            return weightA - weightB;
+        });
+        // Select based on tier
+        switch (tier) {
+            case 'fast':
+                // Cheapest model (lowest weight) - should be Haiku for Claude
+                const cheapest = sorted[0];
+                return cheapest.id;
+            case 'powerful':
+                // Most expensive/powerful model (highest weight) - should be Opus for Claude
+                const mostExpensive = sorted[sorted.length - 1];
+                return mostExpensive.id;
+            case 'balanced':
+            default:
+                // Get middle model (rounded down)
+                const midIndex = Math.floor(sorted.length / 2);
+                const balanced = sorted[midIndex];
+                return balanced.id;
+        }
+    }
+    /**
+     * Get latest models from each tier for all configured providers
+     */
+    async getLatestModelsByTier() {
+        const result = {};
+        if (!this.config.providers)
+            return result;
+        for (const providerName of Object.keys(this.config.providers)) {
+            const fast = await this.getDefaultModelByTier(providerName, 'fast');
+            const balanced = await this.getDefaultModelByTier(providerName, 'balanced');
+            const powerful = await this.getDefaultModelByTier(providerName, 'powerful');
+            if (fast && balanced && powerful) {
+                result[providerName] = { fast, balanced, powerful };
+            }
+        }
+        return result;
+    }
     /**
      * Get usage statistics
      */
@@ -14360,6 +14736,7 @@ class IntentDetectionPlugin {
     }
     /**
      * Resolve model name with dynamic discovery support
+     * Uses cached models when available, falls back to defaults
      */
     resolveModelName() {
         const { provider, model, enableDynamicModelDiscovery } = this.config;
@@ -14367,66 +14744,45 @@ class IntentDetectionPlugin {
         if (model && model !== 'auto') {
             return model;
         }
-        // Default models for each provider
+        // Try to get from cache first
+        if (enableDynamicModelDiscovery) {
+            const cachedFastest = ContextualCommandService.getFastestModelSync(provider);
+            if (cachedFastest) {
+                this.log(`✅ [MODEL RESOLUTION] Using cached fastest model for ${provider}: ${cachedFastest}`);
+                return cachedFastest;
+            }
+        }
+        // Fallback to defaults if cache unavailable (using latest 4-5 models)
         const defaultModels = {
             openai: 'gpt-4o-mini',
-            claude: 'claude-3-haiku-20240307',
-            gemini: 'gemini-flash-latest', // Correct model name
+            claude: 'claude-haiku-4-5-20251001',
+            gemini: 'gemini-1.5-flash',
         };
-        // If dynamic discovery is disabled, use defaults
-        if (!enableDynamicModelDiscovery) {
-            return defaultModels[provider.toLowerCase()] || 'gpt-3.5-turbo';
-        }
-        // For 'auto' or dynamic discovery, we'll resolve at runtime
-        return defaultModels[provider.toLowerCase()] || 'gpt-3.5-turbo';
+        const defaultModel = defaultModels[provider.toLowerCase()] || 'gpt-3.5-turbo';
+        this.log(`⚠️ [MODEL RESOLUTION] Using fallback default for ${provider}: ${defaultModel}`);
+        return defaultModel;
     }
     /**
      * Dynamically discover and select the best model for the provider
+     * Uses cached models when available
      */
     async discoverBestModel() {
-        const { provider, apiKey } = this.config;
-        try {
-            switch (provider.toLowerCase()) {
-                case 'gemini': {
-                    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
-                    const data = await response.json();
-                    if (data.models) {
-                        const geminiModels = data.models
-                            .filter((m) => m.name.includes('gemini'))
-                            .map((m) => m.name.replace('models/', ''));
-                        // Priority order: latest flash > any flash > latest pro > any pro
-                        const latestFlash = geminiModels.find((m) => m === 'gemini-flash-latest');
-                        const anyFlash = geminiModels.find((m) => m.includes('flash') && !m.includes('pro'));
-                        const latestPro = geminiModels.find((m) => m === 'gemini-pro-latest');
-                        const anyPro = geminiModels.find((m) => m.includes('pro'));
-                        const selectedModel = latestFlash || anyFlash || latestPro || anyPro || 'gemini-1.5-flash';
-                        this.log(`🔍 [DYNAMIC DISCOVERY] Found ${geminiModels.length} Gemini models, selected: ${selectedModel}`);
-                        return selectedModel;
-                    }
-                    break;
-                }
-                case 'openai': {
-                    // OpenAI models are more stable, use known fast models
-                    const fastModels = ['gpt-4o-mini', 'gpt-3.5-turbo', 'gpt-4o'];
-                    return fastModels[0]; // gpt-4o-mini is fastest
-                }
-                case 'claude': {
-                    // Claude models are stable, use known fast models
-                    const fastModels = ['claude-3-haiku-20240307', 'claude-3-5-haiku-20241022'];
-                    return fastModels[0]; // haiku is fastest
-                }
-            }
-        }
-        catch (error) {
-            this.log('⚠️ Dynamic model discovery failed, using default:', error);
-        }
-        // Fallback to defaults
+        const { provider } = this.config;
+        // First, try to get from cache (fastest model for the provider)
+        const cachedFastest = ContextualCommandService.getFastestModelSync(provider);
+        if (cachedFastest) {
+            this.log(`✅ [DYNAMIC DISCOVERY] Using cached fastest model for ${provider}: ${cachedFastest}`);
+            return cachedFastest;
+        }
+        // Fallback to defaults if cache unavailable (using latest 4-5 models)
         const defaults = {
             openai: 'gpt-4o-mini',
-            claude: 'claude-3-haiku-20240307',
-            gemini: 'gemini-flash-latest', // Correct model name
+            claude: 'claude-haiku-4-5-20251001',
+            gemini: 'gemini-1.5-flash',
         };
-        return defaults[provider.toLowerCase()] || 'gpt-3.5-turbo';
+        const defaultModel = defaults[provider.toLowerCase()] || 'gpt-3.5-turbo';
+        this.log(`⚠️ [DYNAMIC DISCOVERY] Cache unavailable, using fallback: ${defaultModel}`);
+        return defaultModel;
     }
     createModelInstance() {
         const { provider, apiKey } = this.config;
@@ -14838,7 +15194,7 @@ class TypeScriptAnalyzer {
      * Extract type definitions from a TypeScript file
      */
     extractTypes(filePath) {
-        const content = fs$8.readFileSync(filePath, 'utf8');
+        const content = fs__default.readFileSync(filePath, 'utf8');
         const types = [];
         // Extract interfaces
         const interfaceMatches = content.matchAll(/(?:\/\*\*[\s\S]*?\*\/\s*)?export\s+interface\s+(\w+)(?:\s+extends\s+([\w,\s]+))?\s*\{([\s\S]*?)\n\}/g);
@@ -15084,7 +15440,7 @@ class MonasteryAnalyzer {
      */
     extractModel(filePath) {
         try {
-            const content = fs$8.readFileSync(filePath, 'utf8');
+            const content = fs__default.readFileSync(filePath, 'utf8');
             // Extract model name from filename
             const fileName = filePath.split('/').pop()?.replace(/\.(js|ts)$/, '') || 'unknown';
             const modelName = fileName.charAt(0).toUpperCase() + fileName.slice(1);
@@ -15604,13 +15960,13 @@ class SchemaGenerator extends CommandTrainingCollector {
             }
         }
         // Look in pages directory (common pattern)
-        const pagesDir = path$a.join(this.getRootDir(), 'pages');
-        if (fs$8.existsSync(pagesDir)) {
+        const pagesDir = path__default.join(this.getRootDir(), 'pages');
+        if (fs__default.existsSync(pagesDir)) {
             try {
-                const pageFiles = fs$8.readdirSync(pagesDir, { recursive: true });
+                const pageFiles = fs__default.readdirSync(pagesDir, { recursive: true });
                 for (const file of pageFiles) {
                     if (typeof file === 'string' && file.endsWith('.tsx')) {
-                        tsxFiles.push(path$a.join('pages', file));
+                        tsxFiles.push(path__default.join('pages', file));
                     }
                 }
             }
@@ -15776,12 +16132,12 @@ Provide a single sentence that describes what users can do in this tab.`;
     async saveConfig(config, outputPath) {
         this.log(`\n💾 Saving config to: ${outputPath}`);
         // Ensure output directory exists
-        const dir = path$a.dirname(outputPath);
-        if (!fs$8.existsSync(dir)) {
-            fs$8.mkdirSync(dir, { recursive: true });
+        const dir = path__default.dirname(outputPath);
+        if (!fs__default.existsSync(dir)) {
+            fs__default.mkdirSync(dir, { recursive: true });
         }
         // Write config file
-        fs$8.writeFileSync(outputPath, JSON.stringify(config, null, 2), 'utf8');
+        fs__default.writeFileSync(outputPath, JSON.stringify(config, null, 2), 'utf8');
         this.log(`  ✅ Config saved successfully!`);
     }
     /**
@@ -15791,11 +16147,11 @@ Provide a single sentence that describes what users can do in this tab.`;
         this.log('\n📝 Generating schemas/index.ts...');
         // 1. Scan for Monastery models (server/models/*.js)
         const monasteryModels = [];
-        const modelsDir = path$a.join(this.getRootDir(), 'server/models');
-        if (fs$8.existsSync(modelsDir)) {
-            const modelFiles = fs$8.readdirSync(modelsDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+        const modelsDir = path__default.join(this.getRootDir(), 'server/models');
+        if (fs__default.existsSync(modelsDir)) {
+            const modelFiles = fs__default.readdirSync(modelsDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
             for (const file of modelFiles) {
-                const filePath = path$a.join(modelsDir, file);
+                const filePath = path__default.join(modelsDir, file);
                 const extracted = this.monasteryAnalyzer.extractModel(filePath);
                 if (extracted) {
                     monasteryModels.push(extracted);
@@ -15809,7 +16165,7 @@ Provide a single sentence that describes what users can do in this tab.`;
             try {
                 const types = this.tsAnalyzer.extractTypes(typeFile.filePath);
                 extractedTypes.push(...types);
-                this.log(`  ✅ Extracted ${types.length} types from ${path$a.basename(typeFile.filePath)}`);
+                this.log(`  ✅ Extracted ${types.length} types from ${path__default.basename(typeFile.filePath)}`);
             }
             catch (error) {
                 this.log(`  ⚠️  Failed to extract types from ${typeFile.filePath}: ${error.message}`);
@@ -16039,7 +16395,7 @@ module.exports = {
  * Helper function to run schema generation
  */
 async function generateSchemas(projectRoot, config, options = {}) {
-    const { outputDir = path$a.join(projectRoot, '.orchid-ai'), clientOutputFile = 'schemas.ts', serverOutputFile = 'command-config.json', schemasOutputPath = path$a.join(projectRoot, 'schemas.ts'), // Default: root level
+    const { outputDir = path__default.join(projectRoot, '.orchid-ai'), clientOutputFile = 'schemas.ts', serverOutputFile = 'command-config.json', schemasOutputPath = path__default.join(projectRoot, 'schemas.ts'), // Default: root level
     separateSchemaFiles = false, verboseLogging = false, useAI = false, aiService = null, interactive = false, promptCallback, } = options;
     console.log('🚀 Starting schema generation for project:', projectRoot);
     // Create generator
@@ -16047,34 +16403,34 @@ async function generateSchemas(projectRoot, config, options = {}) {
     // Generate config
     const generatedConfig = await generator.generateConfig();
     // Save server config (JSON)
-    const serverConfigPath = path$a.join(outputDir, serverOutputFile);
+    const serverConfigPath = path__default.join(outputDir, serverOutputFile);
     await generator.saveConfig(generatedConfig, serverConfigPath);
     // Generate schemas file(s)
     const schemasIndexContent = await generator.generateSchemasIndexFile(generatedConfig);
     if (separateSchemaFiles) {
         // Generate individual files per schema
-        const schemasDir = path$a.dirname(schemasOutputPath);
-        if (!fs$8.existsSync(schemasDir)) {
-            fs$8.mkdirSync(schemasDir, { recursive: true });
+        const schemasDir = path__default.dirname(schemasOutputPath);
+        if (!fs__default.existsSync(schemasDir)) {
+            fs__default.mkdirSync(schemasDir, { recursive: true });
             console.log(`📁 Created schemas directory: ${schemasDir}`);
         }
         // TODO: Implement individual file generation
         console.log('⚠️  Separate schema files not yet implemented, using single file');
-        fs$8.writeFileSync(schemasOutputPath, schemasIndexContent, 'utf8');
+        fs__default.writeFileSync(schemasOutputPath, schemasIndexContent, 'utf8');
     }
     else {
         // Generate single schemas file
-        const schemasDir = path$a.dirname(schemasOutputPath);
-        if (!fs$8.existsSync(schemasDir)) {
-            fs$8.mkdirSync(schemasDir, { recursive: true });
+        const schemasDir = path__default.dirname(schemasOutputPath);
+        if (!fs__default.existsSync(schemasDir)) {
+            fs__default.mkdirSync(schemasDir, { recursive: true });
         }
-        fs$8.writeFileSync(schemasOutputPath, schemasIndexContent, 'utf8');
+        fs__default.writeFileSync(schemasOutputPath, schemasIndexContent, 'utf8');
         console.log(`📄 Generated schemas file: ${schemasOutputPath}`);
     }
     // Save client config (TypeScript) - legacy format
-    const clientConfigPath = path$a.join(outputDir, clientOutputFile);
+    const clientConfigPath = path__default.join(outputDir, clientOutputFile);
     const clientConfig = generator.generateClientConfig(generatedConfig);
-    fs$8.writeFileSync(clientConfigPath, clientConfig, 'utf8');
+    fs__default.writeFileSync(clientConfigPath, clientConfig, 'utf8');
     console.log('\n✨ Schema generation complete!');
     console.log(`📁 Output directory: ${outputDir}`);
     console.log(`📄 Schemas file: schemas/index.ts`);