orchid-ai 1.2.2 → 1.2.4

package/dist/index.js

@@ -6,7 +6,7 @@ var reactDom = require('react-dom');
 
 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',
@@ -42,28 +42,28 @@ const DEFAULT_MODELS = {
     ],
     claude: [
         {
-            id: 'claude-opus-4-20250514',
-            name: 'Claude Opus 4',
+            id: 'claude-haiku-4-5-20251001',
+            name: 'Claude Haiku 4.5',
             provider: 'claude',
             available: true,
             supportsImages: true,
-            computeWeight: 1.2,
+            computeWeight: 0.2,
         },
         {
-            id: 'claude-sonnet-4-20250514',
-            name: 'Claude Sonnet 4',
+            id: 'claude-sonnet-4-5-20250929',
+            name: 'Claude Sonnet 4.5',
             provider: 'claude',
             available: true,
             supportsImages: true,
             computeWeight: 0.6,
         },
         {
-            id: 'claude-3-5-haiku-20241022',
-            name: 'Claude Haiku 3.5',
+            id: 'claude-opus-4-20250514',
+            name: 'Claude Opus 4',
             provider: 'claude',
             available: true,
             supportsImages: true,
-            computeWeight: 0.2,
+            computeWeight: 1.2,
         },
     ],
     gemini: [
@@ -404,6 +404,45 @@ function useStreamingAI({ userId, serverConfig, formData, chats: externalChats,
                 additionalContext ? (typeof additionalContext === 'string' ? additionalContext : JSON.stringify(additionalContext)) : '',
                 context || ''
             ].filter(Boolean).join('\n\n');
+            // Prepare model selection for request
+            // Safety: ensure model matches provider; if mismatched, drop/replace model to avoid provider/model conflicts (e.g., Gemini with Claude model ID)
+            const normalizeModelSelection = (sel) => {
+                const provider = (sel.provider || '').toLowerCase();
+                const model = sel.model || '';
+                // Heuristic: if model prefix clearly belongs to another provider, treat as mismatch
+                const belongsToProvider = (prov, m) => {
+                    if (!m)
+                        return true;
+                    const id = m.toLowerCase();
+                    if (prov === 'gemini' || prov === 'google')
+                        return id.startsWith('gemini');
+                    if (prov === 'claude' || prov === 'anthropic')
+                        return id.startsWith('claude');
+                    if (prov === 'openai')
+                        return id.startsWith('gpt');
+                    return true;
+                };
+                if (!belongsToProvider(provider, model)) {
+                    // Mismatch: prefer tier if provided, otherwise drop model so server can choose; as last resort, use DEFAULT_CONFIG when same provider
+                    const normalized = { provider };
+                    if (sel.tier)
+                        normalized.tier = sel.tier;
+                    // Only keep model if it matches provider
+                    return normalized;
+                }
+                return sel;
+            };
+            const requestModelSelection = modelSelection
+                ? normalizeModelSelection({
+                    provider: modelSelection.provider,
+                    ...(modelSelection.model ? { model: modelSelection.model } : {}),
+                    ...(modelSelection.tier ? { tier: modelSelection.tier } : {}),
+                })
+                : {
+                    provider: DEFAULT_CONFIG.service,
+                    model: DEFAULT_CONFIG.model,
+                };
+            // Request log removed; rely on verbose-controlled logger if needed
             const requestBody = {
                 query,
                 userId,
@@ -412,14 +451,7 @@ function useStreamingAI({ userId, serverConfig, formData, chats: externalChats,
                 formData: formData || {},
                 files: processedFiles,
                 // New: Include model selection in request
-                modelSelection: modelSelection || {
-                    provider: DEFAULT_CONFIG.service,
-                    model: DEFAULT_CONFIG.model,
-                    capabilities: {
-                        supportsImages: DEFAULT_CONFIG.supportsImages,
-                        computeWeight: 1.0,
-                    },
-                },
+                modelSelection: requestModelSelection,
                 ...(schema ? { schema } : {}), // <-- NEW: Include schema from serverConfig!
                 ...(mergedContext ? { additionalContext: mergedContext } : {}), // <-- Include merged context
             };
@@ -1070,6 +1102,65 @@ function useDebouncedSuggestions(query, options) {
     };
 }
 
+/**
+ * Hook to resolve tier-based default model config to actual model
+ *
+ * This hook takes a default model configuration that may include a tier
+ * (like 'fast', 'balanced', 'powerful') and resolves it to an actual model
+ * by fetching the available models from the server and selecting the best
+ * match for the provider and tier combination.
+ *
+ * @param defaultModel - The model configuration to resolve
+ * @returns The resolved model with provider, model name, and capabilities
+ */
+function useResolvedDefaultModel(defaultModel) {
+    const [resolvedModel, setResolvedModel] = React.useState();
+    React.useEffect(() => {
+        if (!defaultModel || defaultModel.model) {
+            // If no config or explicit model provided, set resolved model directly
+            if (defaultModel) {
+                setResolvedModel({
+                    provider: defaultModel.provider,
+                    model: defaultModel.model,
+                    capabilities: { supportsImages: false, computeWeight: 1.0 }, // Default capabilities
+                });
+            }
+            return;
+        }
+        // Need to resolve tier to actual model
+        const resolveModel = async () => {
+            try {
+                const response = await fetch('/command/models');
+                if (!response.ok)
+                    throw new Error('Failed to fetch models');
+                const data = await response.json();
+                const modelsByTier = data.modelsByTier || {};
+                // Get the model for the requested provider and tier
+                const providerModels = modelsByTier[defaultModel.provider];
+                if (providerModels && providerModels[defaultModel.tier]) {
+                    const modelName = providerModels[defaultModel.tier];
+                    setResolvedModel({
+                        provider: defaultModel.provider,
+                        model: modelName,
+                        capabilities: { supportsImages: false, computeWeight: 1.0 }, // Will be updated by server
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Failed to resolve default model:', error);
+                // Fallback to a reasonable default
+                setResolvedModel({
+                    provider: defaultModel.provider,
+                    model: `${defaultModel.provider}-default`,
+                    capabilities: { supportsImages: false, computeWeight: 1.0 },
+                });
+            }
+        };
+        resolveModel();
+    }, [defaultModel]);
+    return resolvedModel;
+}
+
 // Size mapping
 const sizeMap = {
     xs: 12,
@@ -1929,14 +2020,68 @@ const FileHandler = {
     },
 };
 
-function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialModel = DEFAULT_CONFIG.model, customModels, } = {}) {
-    // Use default models or custom models
-    const availableModels = customModels || DEFAULT_MODELS;
+// Helper function to build URL from config (reused from useStreamingAI)
+function buildUrlFromConfig(config) {
+    if (typeof window === 'undefined')
+        return config.suffix || '/api';
+    const protocol = config.secure !== undefined
+        ? config.secure
+            ? 'https:'
+            : 'http:'
+        : window.location.protocol;
+    const hostname = config.domain || window.location.hostname;
+    const port = config.port
+        ? `:${config.port}`
+        : window.location.port
+            ? `:${window.location.port}`
+            : '';
+    const suffix = config.suffix || '';
+    // If no domain specified, use relative URL (common with webpack proxy)
+    if (!config.domain && !config.port && !config.secure) {
+        return suffix;
+    }
+    return `${protocol}//${hostname}${port}${suffix}`;
+}
+function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialModel, initialTier, // Can be undefined - don't default here, let Conversation handle it
+customModels, serverConfig, } = {}) {
+    // Use provided initialModel if available
+    // If tier is specified without model, use empty string (server will handle tier-based selection)
+    // DO NOT use DEFAULT_CONFIG.model here - it will interfere with tier-based selection
+    // We'll only auto-select a model later if no tier is specified AND models are available
+    const effectiveInitialModel = initialModel || '';
+    // State for auto-fetched models
+    const [fetchedModels, setFetchedModels] = React.useState(null);
+    const [isLoadingModels, setIsLoadingModels] = React.useState(false);
+    const [modelsError, setModelsError] = React.useState(null);
+    // Track if user explicitly switched models; prevents defaultModel overrides after first user action
+    const [hasUserSwitched, setHasUserSwitched] = React.useState(false);
+    // Determine which models to use
+    // Priority: customModels > fetchedModels > DEFAULT_MODELS
+    const availableModels = customModels || fetchedModels || DEFAULT_MODELS;
     // Simple state management - no API calls
+    // If tier is specified without explicit model, use empty string to signal tier-based selection
+    // If no tier and no model, use effectiveInitialModel (which may be DEFAULT_CONFIG.model as last resort)
     const [currentModel, setCurrentModel] = React.useState({
         provider: initialProvider,
-        model: initialModel,
+        model: effectiveInitialModel,
     });
+    // Update model when initialTier/initialModel change (e.g., when defaultModel prop becomes available)
+    React.useEffect(() => {
+        if (hasUserSwitched) {
+            // Respect user choice; do not override with defaults after first manual switch
+            return;
+        }
+        if (initialTier && !initialModel) {
+            // Tier-based selection: clear model so server handles it
+            if (currentModel.model !== '') {
+                setCurrentModel(prev => ({ ...prev, model: '' }));
+            }
+        }
+        else if (initialModel && currentModel.model !== initialModel) {
+            // Explicit model specified: use it
+            setCurrentModel(prev => ({ ...prev, model: initialModel }));
+        }
+    }, [initialTier, initialModel, currentModel.model, hasUserSwitched]);
     const [usageStats, setUsageStats] = React.useState({
         requests: 0,
         totalTokens: 0,
@@ -1945,10 +2090,126 @@ function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialMod
         uptime: 0,
         providers: [],
         currentProvider: initialProvider,
-        currentModel: initialModel,
+        currentModel: effectiveInitialModel,
     });
     // Track session start time for uptime calculation
     const [sessionStartTime] = React.useState(Date.now());
+    // Auto-fetch models from server if customModels not provided and serverConfig is available
+    React.useEffect(() => {
+        // Only fetch if:
+        // 1. No custom models provided
+        // 2. Server config is available
+        // 3. Haven't fetched yet
+        if (customModels || !serverConfig || fetchedModels !== null || isLoadingModels) {
+            return;
+        }
+        const fetchModels = async () => {
+            setIsLoadingModels(true);
+            setModelsError(null);
+            try {
+                const apiUrl = buildUrlFromConfig(serverConfig);
+                const modelsEndpoint = `${apiUrl}/models`;
+                const response = await fetch(modelsEndpoint);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch models: ${response.statusText}`);
+                }
+                const data = await response.json();
+                if (data.status === 'ok' && data.models) {
+                    // Transform server response into the format expected by the hook
+                    const modelsByProvider = {};
+                    // Group models by provider
+                    data.models.forEach((model) => {
+                        const provider = model.provider.toLowerCase();
+                        if (!modelsByProvider[provider]) {
+                            modelsByProvider[provider] = [];
+                        }
+                        modelsByProvider[provider].push({
+                            id: model.id,
+                            name: model.name || model.id,
+                            provider: provider,
+                            available: model.available !== false,
+                            supportsImages: model.supportsImages || false,
+                            computeWeight: model.computeWeight || 0.5,
+                            description: model.description || '',
+                        });
+                    });
+                    setFetchedModels(modelsByProvider);
+                }
+                else {
+                    throw new Error('Invalid response format from models endpoint');
+                }
+            }
+            catch (error) {
+                console.warn('⚠️ Could not auto-fetch models from server, using defaults:', error);
+                setModelsError(error instanceof Error ? error.message : 'Unknown error');
+                // Continue with DEFAULT_MODELS as fallback
+                setFetchedModels({}); // Set to empty object to prevent retry
+            }
+            finally {
+                setIsLoadingModels(false);
+            }
+        };
+        fetchModels();
+    }, [customModels, serverConfig, fetchedModels, isLoadingModels]);
+    // Update initial model if we fetched models and need to auto-select from tier
+    // BUT: If initialTier is specified, we should NOT auto-select here - let server handle tier selection
+    React.useEffect(() => {
+        // Only auto-select if:
+        // 1. We have fetched models
+        // 2. We're using the default initial model (or no model specified)
+        // 3. NO tier is specified (tier-based selection should happen server-side)
+        // 4. Current model still has the initial model
+        if (fetchedModels && Object.keys(fetchedModels).length > 0) {
+            // If tier is specified, don't auto-select - server will handle tier selection
+            // This prevents the hook from selecting a model when tier-based selection is desired
+            if (initialTier) {
+                return;
+            }
+            // Auto-select only if:
+            // 1. No tier specified (tier-based selection should be server-side)
+            // 2. No explicit model provided
+            // 3. Current model is empty (needs selection)
+            // This ensures we pick the cheapest model when no preference is given
+            const shouldAutoSelect = (!initialTier) && // Don't auto-select if tier is specified
+                (!initialModel) && // Don't auto-select if explicit model provided
+                currentModel.model === ''; // Only if empty (need to select something)
+            if (shouldAutoSelect) {
+                const providerModels = fetchedModels[initialProvider];
+                if (providerModels && providerModels.length > 0) {
+                    // Sort models by computeWeight
+                    const sorted = [...providerModels].sort((a, b) => {
+                        const weightA = a.computeWeight || 0.5;
+                        const weightB = b.computeWeight || 0.5;
+                        return weightA - weightB;
+                    });
+                    // Select model based on tier (default to fast/cheapest)
+                    // Note: This should only run if initialTier is NOT specified (we return early above if it is)
+                    // But we still default to 'fast' here as a fallback
+                    let selectedModel;
+                    const tier = (initialTier || 'fast');
+                    switch (tier) {
+                        case 'fast':
+                            selectedModel = sorted[0]; // First item = lowest weight = cheapest
+                            break;
+                        case 'powerful':
+                            selectedModel = sorted[sorted.length - 1]; // Last item = highest weight = most powerful
+                            break;
+                        case 'balanced':
+                        default:
+                            // Middle model (rounded down)
+                            selectedModel = sorted[Math.floor(sorted.length / 2)];
+                            break;
+                    }
+                    if (selectedModel) {
+                        setCurrentModel({
+                            provider: initialProvider,
+                            model: selectedModel.id,
+                        });
+                    }
+                }
+            }
+        }
+    }, [fetchedModels, initialProvider, initialTier, effectiveInitialModel, currentModel.model]);
     // Switch model function - just updates local state
     const switchModel = React.useCallback((model, provider) => {
         const newProvider = provider || currentModel.provider;
@@ -1957,6 +2218,8 @@ function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialMod
             provider: newProvider,
             model: model,
         });
+        // Mark that user has made an explicit selection
+        setHasUserSwitched(true);
         // Update usage stats
         setUsageStats(prev => ({
             ...prev,
@@ -2011,11 +2274,17 @@ function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialMod
         };
     }, [currentModel, availableModels]);
     // Get current model info for streaming API
-    const getCurrentModelInfo = React.useCallback(() => ({
-        provider: currentModel.provider,
-        model: currentModel.model,
-        capabilities: getCurrentCapabilities(),
-    }), [currentModel, getCurrentCapabilities]);
+    // Returns null if model is empty (tier-based selection is being used)
+    const getCurrentModelInfo = React.useCallback(() => {
+        if (!currentModel.model) {
+            return null; // Empty model means tier-based selection is active
+        }
+        return {
+            provider: currentModel.provider,
+            model: currentModel.model,
+            capabilities: getCurrentCapabilities(),
+        };
+    }, [currentModel, getCurrentCapabilities]);
     // Flatten models for backward compatibility
     const models = Object.values(availableModels).flat();
     const modelsByProvider = availableModels;
@@ -2027,8 +2296,8 @@ function useModelSwitcher({ initialProvider = DEFAULT_CONFIG.service, initialMod
         currentModel,
         currentCapabilities,
         usageStats,
-        isLoading: false, // No loading since no API calls
-        error: null,
+        isLoading: isLoadingModels,
+        error: modelsError,
         // Actions
         switchModel,
         trackUsage,
@@ -2070,6 +2339,25 @@ theme, onModelSelectionChange, }) {
         initialProvider: defaultModel?.provider,
         initialModel: defaultModel?.model,
     });
+    // Helper: compute a display-only model object when provider/model mismatch exists (no state writes to avoid loops)
+    const getDisplayModelForHeader = () => {
+        if (!currentModel)
+            return null;
+        const provider = (currentModel.provider || '').toLowerCase();
+        const modelId = (currentModel.model || '').toLowerCase();
+        const allModels = Object.values(modelsByProvider || {}).flat();
+        const exact = allModels.find((m) => m.id.toLowerCase() === modelId && (m.provider || '').toLowerCase() === provider);
+        if (exact)
+            return exact;
+        // Fallback: pick a sensible default for the provider without mutating state
+        const providerModels = (modelsByProvider && modelsByProvider[provider] && modelsByProvider[provider].length > 0)
+            ? modelsByProvider[provider]
+            : DEFAULT_MODELS[provider] || [];
+        if (providerModels.length > 0) {
+            return [...providerModels].sort((a, b) => (a.computeWeight || 0.5) - (b.computeWeight || 0.5))[0];
+        }
+        return null;
+    };
     const lastModelRef = React.useRef(null);
     React.useEffect(() => {
         if (onModelSelectionChange && currentModel && currentCapabilities) {
@@ -2207,10 +2495,11 @@ theme, onModelSelectionChange, }) {
     const getCurrentModelName = () => {
         if (!currentModel)
             return 'AI Model';
-        // Find the actual model object to get the name
-        const allModels = Object.values(modelsByProvider).flat();
-        const modelObj = allModels.find((m) => m.id === currentModel.model && m.provider === currentModel.provider);
-        return modelObj?.name || currentModel.model;
+        // Prefer exact match; otherwise, display a sensible provider default without mutating state
+        const modelObj = getDisplayModelForHeader();
+        if (modelObj)
+            return modelObj.name || modelObj.id;
+        return currentModel.model || 'AI Model';
     };
     // Get model-specific usage for tooltip
     const getModelUsage = (modelId, provider) => {
@@ -2442,11 +2731,77 @@ additionalContext, }) {
     const [attachedFiles, setAttachedFiles] = React.useState(externalAttachedFiles);
     const [currentModelSelection, setCurrentModelSelection] = React.useState(externalCurrentModelSelection);
     // Use the simplified model switcher hook
-    const { trackUsage } = useModelSwitcher({
+    // If models not provided, it will auto-fetch from server using serverConfig
+    // If defaultModel only has provider (no model), it will auto-select from specified tier (defaults to 'fast')
+    const { trackUsage, getCurrentModelInfo } = useModelSwitcher({
         customModels: models,
         initialProvider: defaultModel?.provider,
-        initialModel: defaultModel?.model,
+        initialModel: defaultModel?.model, // Can be undefined to auto-select from tier
+        initialTier: defaultModel?.tier, // Pass tier for auto-selection
+        serverConfig: serverConfig, // Pass serverConfig for auto-fetching models
     });
+    // Get current model info with tier if available
+    // CRITICAL: If defaultModel has tier, ALWAYS use tier for server-side selection
+    // This ensures tier-based selection even if hook has auto-selected a model
+    const getModelSelection = React.useCallback(() => {
+        // Helper to ensure provider/model consistency at the last moment
+        const belongsToProvider = (prov, m) => {
+            if (!m)
+                return true;
+            const id = m.toLowerCase();
+            const p = (prov || '').toLowerCase();
+            if (p === 'gemini' || p === 'google')
+                return id.startsWith('gemini');
+            if (p === 'claude' || p === 'anthropic')
+                return id.startsWith('claude');
+            if (p === 'openai')
+                return id.startsWith('gpt');
+            return true;
+        };
+        // Priority 1: If defaultModel specifies a tier, ALWAYS use tier for server-side selection
+        // This overrides ANY model selection (auto-selected or user-selected) to ensure tier is respected
+        if (defaultModel?.tier && !defaultModel?.model) {
+            const provider = currentModelSelection?.provider || defaultModel.provider || 'claude';
+            const selection = {
+                provider,
+                tier: defaultModel.tier,
+            };
+            return selection;
+        }
+        // Priority 2: If currentModelSelection exists with an explicit model, use it
+        if (currentModelSelection && currentModelSelection.model) {
+            let selection = {
+                provider: currentModelSelection.provider,
+                model: currentModelSelection.model,
+            };
+            // Final guard: if model doesn't belong to provider, drop model so server picks correctly
+            if (!belongsToProvider(selection.provider, selection.model)) {
+                selection = { provider: selection.provider };
+            }
+            return selection;
+        }
+        // Priority 3: Use getCurrentModelInfo from hook
+        const modelInfo = getCurrentModelInfo();
+        if (modelInfo && modelInfo.model) {
+            const selection = {
+                provider: modelInfo.provider,
+                model: modelInfo.model,
+            };
+            return selection;
+        }
+        // Priority 4: Fallback - use defaultModel tier/provider if available
+        if (defaultModel?.provider) {
+            const selection = {
+                provider: defaultModel.provider,
+                ...(defaultModel.tier ? { tier: defaultModel.tier } : {}),
+                ...(defaultModel.model ? { model: defaultModel.model } : {}),
+            };
+            return selection;
+        }
+        console.warn('[Conversation] ⚠️ No model selection available - returning undefined');
+        console.warn('[Conversation] ⚠️ This will cause the server to use DEFAULT_CONFIG.model fallback');
+        return undefined;
+    }, [currentModelSelection, defaultModel, getCurrentModelInfo]);
     // Use streaming AI hook for AI functionality
     const streamingAI = useStreamingAI({
         userId,
@@ -2456,15 +2811,46 @@ additionalContext, }) {
         setChats: externalSetChats,
         currentChatId: externalCurrentChatId,
         setCurrentChatId: externalSetCurrentChatId,
-        modelSelection: currentModelSelection,
+        modelSelection: getModelSelection(),
         onUsageTracked: trackUsage,
         chatLevel,
         additionalContext,
     });
     // Handle model selection changes
     const handleModelSelectionChange = React.useCallback((modelInfo) => {
-        setCurrentModelSelection(modelInfo);
-        externalOnModelSelectionChange?.(modelInfo);
+        // Normalize provider/model pair to prevent mismatches (e.g., openai + claude-haiku)
+        const provider = (modelInfo.provider || '').toLowerCase();
+        const modelId = (modelInfo.model || '').toLowerCase();
+        const belongsToProvider = (prov, m) => {
+            if (!m)
+                return true;
+            if (prov === 'gemini' || prov === 'google')
+                return m.startsWith('gemini');
+            if (prov === 'claude' || prov === 'anthropic')
+                return m.startsWith('claude');
+            if (prov === 'openai')
+                return m.startsWith('gpt');
+            return true;
+        };
+        let normalized = modelInfo;
+        if (!belongsToProvider(provider, modelId)) {
+            // Pick a sensible default for the selected provider: lowest computeWeight
+            const providerModels = DEFAULT_MODELS[provider] || [];
+            const selected = [...providerModels].sort((a, b) => (a.computeWeight || 0.5) - (b.computeWeight || 0.5))[0];
+            if (selected) {
+                normalized = {
+                    provider: provider,
+                    model: selected.id,
+                    capabilities: { supportsImages: selected.supportsImages || false, computeWeight: selected.computeWeight || 1.0 },
+                };
+            }
+            else {
+                // If no known models, drop to provider with same model string (will be corrected later in request layer)
+                normalized = { ...modelInfo, model: '' };
+            }
+        }
+        setCurrentModelSelection(normalized);
+        externalOnModelSelectionChange?.(normalized);
     }, [externalOnModelSelectionChange]);
     // Handle sending messages
     const handleSend = React.useCallback((additionalContext, queryToSend) => {
@@ -3421,6 +3807,7 @@ exports.mergeWithAi = mergeWithAi;
 exports.useAiMerge = useAiMerge;
 exports.useDebouncedSuggestions = useDebouncedSuggestions;
 exports.useModelSwitcher = useModelSwitcher;
+exports.useResolvedDefaultModel = useResolvedDefaultModel;
 exports.useStreamingAI = useStreamingAI;
 exports.useSuggestions = useSuggestions;
 //# sourceMappingURL=index.js.map

package/dist/server/components/ChatPanel.d.ts

@@ -20,7 +20,8 @@ interface ChatPanelProps {
     models?: Record<string, ModelInfo[]>;
     defaultModel?: {
         provider: string;
-        model: string;
+        model?: string;
+        tier?: 'fast' | 'balanced' | 'powerful';
     };
     showUsageStats?: boolean;
     maxFileSize?: string;

package/dist/server/components/Conversation.d.ts

@@ -27,7 +27,8 @@ interface ConversationProps {
     models?: Record<string, ModelInfo[]>;
     defaultModel?: {
         provider: string;
-        model: string;
+        model?: string;
+        tier?: 'fast' | 'balanced' | 'powerful';
     };
     showUsageStats?: boolean;
     maxFileSize?: string;

package/dist/server/components/ModelSwitcher.d.ts

@@ -4,7 +4,8 @@ interface ModelSwitcherProps {
     models?: Record<string, ModelInfo[]>;
     defaultModel?: {
         provider: string;
-        model: string;
+        model?: string;
+        tier?: 'fast' | 'balanced' | 'powerful';
     };
     showUsageStats?: boolean;
     theme?: ChatTheme;