orchid-ai 1.2.2 → 1.2.4

package/dist/server/contextual-service.d.ts

@@ -1,9 +1,20 @@
 import type { ContextualServiceConfig, ContextualRequest } from '../types/types.js';
 export declare class ContextualCommandService {
     private config;
+    private modelsCache;
+    private cacheFilePath;
+    private readonly CACHE_TTL_MS;
     private verboseLogging;
     private usage;
     constructor(config: ContextualServiceConfig);
+    /**
+     * Load models cache from file if it exists and is fresh
+     */
+    private loadModelsCache;
+    /**
+     * Save models cache to file
+     */
+    private saveModelsCache;
     private autoConfigureProviders;
     private log;
     private handleError;
@@ -30,14 +41,51 @@ export declare class ContextualCommandService {
      */
     getSuggestions(request: ContextualRequest): Promise<any[]>;
     /**
-     * Get available models
+     * Static utility to read cached models from file (for use in other services)
+     */
+    static getCachedModelsSync(): Array<{
+        id: string;
+        name: string;
+        provider: string;
+        available: boolean;
+        computeWeight?: number;
+        supportsImages?: boolean;
+    }>;
+    /**
+     * Static utility to get the fastest model for a provider from cache
+     */
+    static getFastestModelSync(provider: string): string | null;
+    /**
+     * Get available models from API or use cached/defaults
+     * Uses file-based cache that refreshes every 24 hours
      */
     getAvailableModels(): Promise<{
         id: string;
         name: string;
         provider: string;
         available: boolean;
+        computeWeight?: number;
+        supportsImages?: boolean;
     }[]>;
+    /**
+     * 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
+     */
+    getLatestDefaultModel(provider?: string): Promise<string>;
+    /**
+     * 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)
+     */
+    getDefaultModelByTier(provider: string, tier?: 'fast' | 'balanced' | 'powerful'): Promise<string | null>;
+    /**
+     * Get latest models from each tier for all configured providers
+     */
+    getLatestModelsByTier(): Promise<Record<string, {
+        fast: string;
+        balanced: string;
+        powerful: string;
+    }>>;
     /**
      * Get usage statistics
      */

package/dist/server/hooks/useModelSwitcher.d.ts

@@ -1,4 +1,4 @@
-import { ModelInfo } from '../types/types';
+import { ModelInfo, ServerConfig } from '../types/types';
 interface CurrentModel {
     provider: string;
     model: string;
@@ -25,16 +25,19 @@ interface UsageStats {
 interface UseModelSwitcherOptions {
     initialProvider?: string;
     initialModel?: string;
+    initialTier?: 'fast' | 'balanced' | 'powerful';
     customModels?: Record<string, ModelInfo[]>;
+    serverConfig?: ServerConfig;
 }
-export declare function useModelSwitcher({ initialProvider, initialModel, customModels, }?: UseModelSwitcherOptions): {
+export declare function useModelSwitcher({ initialProvider, initialModel, initialTier, // Can be undefined - don't default here, let Conversation handle it
+customModels, serverConfig, }?: UseModelSwitcherOptions): {
     models: ModelInfo[];
     modelsByProvider: Record<string, ModelInfo[]>;
     currentModel: CurrentModel;
     currentCapabilities: ModelCapabilities;
     usageStats: UsageStats;
     isLoading: boolean;
-    error: null;
+    error: string | null;
     switchModel: (model: string, provider?: string) => {
         success: boolean;
         current: {
@@ -48,7 +51,7 @@ export declare function useModelSwitcher({ initialProvider, initialModel, custom
         provider: string;
         model: string;
         capabilities: ModelCapabilities;
-    };
+    } | null;
     modelState: {
         models: ModelInfo[];
         current: CurrentModel;

package/dist/server/hooks/useResolvedDefaultModel.d.ts

@@ -0,0 +1,21 @@
+import type { ModelCapabilities } from '../types/types';
+/**
+ * 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
+ */
+export declare function useResolvedDefaultModel(defaultModel?: {
+    provider: string;
+    model?: string;
+    tier?: 'fast' | 'balanced' | 'powerful';
+}): {
+    provider: string;
+    model: string;
+    capabilities: ModelCapabilities;
+} | undefined;

package/dist/server/hooks/useStreamingAI.d.ts

@@ -1,8 +1,9 @@
 import { ChatMessage, ModelCapabilities, ServerConfig } from '../types/types';
 interface ModelSelection {
     provider: string;
-    model: string;
-    capabilities: ModelCapabilities;
+    model?: string;
+    tier?: 'fast' | 'balanced' | 'powerful';
+    capabilities?: ModelCapabilities;
 }
 export declare function useStreamingAI({ userId, serverConfig, formData, chats: externalChats, setChats: externalSetChats, currentChatId: externalCurrentChatId, setCurrentChatId: externalSetCurrentChatId, modelSelection, onUsageTracked, chatLevel, additionalContext, verbose, }: {
     userId: string;