orchid-ai 1.0.0

package/dist/server/server/utils.d.ts

@@ -0,0 +1,209 @@
+import { AnalysisContext, CommandSuggestion, Intent, RouteConfig, TrainingData } from '../types/types';
+export declare function sanitizeFormData(formData: Record<string, any> | undefined): Record<string, any>;
+export declare function handleError(error: unknown, prefix?: string, verboseLogging?: boolean): void;
+export declare function extractFirstJsonArray(text: string): any;
+export declare function getModelSupportsImages(modelId: string, provider: string): boolean;
+/**
+ * Check if the current model supports image input
+ * @returns {boolean} True if current model supports images
+ */
+export declare function currentModelSupportsImages(): string;
+export declare function getDefaultModelsForProvider(provider: string): {
+    id: string;
+    name: string;
+    provider: string;
+    available: boolean;
+    supportsImages: boolean;
+}[] | {
+    id: string;
+    name: string;
+    provider: string;
+    available: boolean;
+    supportsImages: boolean;
+}[] | {
+    id: string;
+    name: string;
+    provider: string;
+    available: boolean;
+    supportsImages: boolean;
+}[];
+/**
+ * Enhanced context analysis for better AI suggestions
+ * Analyzes chat history to extract relevant context for form state management
+ */
+export declare function analyzeContext(chatHistory: any[], currentCommand: string): AnalysisContext;
+/**
+ * Extract entities (quotes, customers, shipments) from message content
+ */
+export declare function extractEntitiesFromMessage(content: string, context: any): void;
+/**
+ * Extract form state information from message content
+ */
+export declare function extractFormStateFromMessage(content: string, context: any): void;
+/**
+ * Extract user preferences and patterns from message content
+ */
+export declare function extractUserPreferencesFromMessage(content: string, context: any): void;
+/**
+ * Track recent actions for continuity
+ */
+export declare function trackRecentActions(content: string, context: any): void;
+/**
+ * Extract data from current command
+ */
+export declare function extractDataFromCommand(command: string, context: any): void;
+/**
+ * Classify user intent based on command and context
+ */
+export declare function classifyIntent(command: string, context: any): Intent;
+/**
+ * Determine action type based on context and intent
+ */
+export declare function determineActionType(context: any, intent: string | null): "create" | "edit" | "view";
+/**
+ * Helper: Parse and fix JSON response from any provider
+ */
+export declare function parseAndFixJsonResponse(content: string, provider: string): any[];
+/**
+ * Helper: Safely parse JSON that might contain JavaScript expressions
+ * Replaces common JS expressions (e.g., new Date(), Date.now()) with JSON-safe values
+ * Returns parsed object/array on success, or null on failure
+ */
+export declare function parseJsonWithExpressions(str: string): any;
+/**
+ * Helper: Enhance suggestions with actionType and context
+ */
+export declare function enhanceSuggestions(suggestions: any, context: any): CommandSuggestion[];
+/**
+ * Helper: Create fallback suggestions
+ */
+export declare function createFallbackSuggestions(message?: string): {
+    action: string;
+    actionType: string;
+    path: string;
+    formState: {};
+    message: string;
+}[];
+/**
+ * Dynamic route validation based on training data
+ */
+export declare function isValidRoute(path: string, routes: RouteConfig[]): boolean;
+/**
+ * Unified JSON extraction function for all models
+ * Extracts ALL JSON objects from text and maintains their order
+ */
+export declare function extractAllJsonFromText(text: string, provider: string): Array<{
+    type: 'array' | 'object';
+    content: string;
+    startIndex: number;
+    endIndex: number;
+}>;
+/**
+ * Check if JSON is actually complete (not just balanced brackets)
+ */
+export declare function isJsonActuallyComplete(str: string): boolean;
+/**
+ * Enhanced JSON depth tracking that handles nested structures properly
+ */
+export declare function calculateJsonDepth(str: string): number;
+/**
+ * Enhanced suggestion extraction with better error handling
+ */
+export declare function extractSuggestions(jsonStr: string): any;
+/**
+ * Extract JSON from streamed text, handling both markdown code blocks and raw JSON
+ * Returns the cleaned text and extracted JSON with completion status
+ */
+export declare function extractJsonFromStream(input: string): {
+    text: string;
+    json: string;
+    isJsonComplete: boolean;
+    isMarkdownBlock: boolean;
+};
+/**
+ * Extract partial JSON from potentially incomplete string
+ */
+export declare function extractPartialJson(str: string): string | null;
+/**
+ * Validate JSON structure and attempt to fix common issues
+ * Now includes bulletproof JavaScript expression evaluation
+ */
+export declare function validateAndFixJson(str: string): string | null;
+/**
+ * Bulletproof JavaScript expression evaluator
+ * Safely evaluates common JavaScript expressions in JSON strings
+ */
+export declare function evaluateJavaScriptExpressions(str: string): string;
+export declare function buildSystemPrompt(trainingData: TrainingData | undefined, chatLevel: 'full' | 'basic' | 'none' | undefined, provider?: string): string;
+/**
+ * Get chat level specific instructions
+ * CRITICAL: These contain the JSON format requirements and must be preserved
+ */
+export declare function getChatLevelInstructions(chatLevel: 'full' | 'basic' | 'none' | undefined): string;
+export declare function prepareMessageWithImages(command: string, images: any[], provider?: string | null): Promise<string | ({
+    type: string;
+    source: {
+        type: string;
+        media_type: any;
+        data: any;
+    };
+    image_url?: undefined;
+    inlineData?: undefined;
+} | {
+    type: string;
+    image_url: {
+        url: string;
+    };
+    source?: undefined;
+    inlineData?: undefined;
+} | {
+    inlineData: {
+        mimeType: any;
+        data: any;
+    };
+    type?: undefined;
+    source?: undefined;
+    image_url?: undefined;
+} | {
+    text: string;
+    type?: undefined;
+} | {
+    type: string;
+    text: string;
+})[]>;
+export declare function processImageForAI(image: any, provider?: string | null): Promise<{
+    type: string;
+    source: {
+        type: string;
+        media_type: any;
+        data: any;
+    };
+    image_url?: undefined;
+    inlineData?: undefined;
+} | {
+    type: string;
+    image_url: {
+        url: string;
+    };
+    source?: undefined;
+    inlineData?: undefined;
+} | {
+    inlineData: {
+        mimeType: any;
+        data: any;
+    };
+    type?: undefined;
+    source?: undefined;
+    image_url?: undefined;
+}>;
+export declare function detectImageTypeFromBase64(base64Data: string): "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/heic" | "image/heif";
+/**
+ * Comprehensive text cleaning utility that removes JSON blocks and related content
+ * This consolidates all the scattered cleaning logic into one place
+ */
+export declare function cleanStreamedText(text: string): string;
+/**
+ * Detect if text contains the start of a JSON code block
+ * Used by frontend to show loading suggestions component
+ */
+export declare function detectJsonBlockStart(text: string): boolean;

package/dist/server/server.d.ts

@@ -0,0 +1,32 @@
+import type { CommandConfig, RouteConfig, TrainingCustomData, AIProvider, AIServiceConfig } from '../types/types.js';
+export interface ServerOptions extends AIServiceConfig {
+    port?: number;
+    baseDir?: string;
+    service?: AIProvider;
+    apiKey?: string;
+    customTrainingData?: TrainingCustomData;
+    routes?: (string | RouteConfig)[];
+}
+export interface CommandServer {
+    app: any;
+    start: () => void;
+    stop: () => void;
+    getConfig: () => CommandConfig;
+}
+/**
+ * Helper function to format error messages for user-friendly display
+ */
+export declare function formatErrorForUser(error: Error): {
+    message: string;
+    type: string;
+    retryAfter?: number;
+};
+/**
+ * Setup a command server with training data collection and streaming support.
+ * Works both as a standalone server and as middleware for existing Express apps.
+ */
+export declare function setupCommandServer(options?: ServerOptions): Promise<CommandServer>;
+/**
+ * Create a command configuration by merging training data from multiple sources
+ */
+export declare function createCommandConfig(options: ServerOptions): Promise<CommandConfig>;

package/dist/server/service.d.ts

@@ -0,0 +1,267 @@
+import { OpenAI } from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import Anthropic from '@anthropic-ai/sdk';
+import { TrainingDataPaths, AIServiceConfig, ImageContent } from '../types/types.js';
+export declare class CommandService {
+    private aiConfig;
+    private verboseLogging;
+    private model;
+    private modelConfig;
+    private usage;
+    constructor(config: AIServiceConfig, verboseLogging?: boolean);
+    private autoConfigureProviders;
+    private log;
+    private handleError;
+    /**
+     * Initialize the service with training data
+     * This must be called before using the service
+     */
+    initialize(): Promise<void>;
+    initializeTrainingData(): Promise<void>;
+    writeConfigToFile(): Promise<void>;
+    writeFailedJsonToFile(failedJson: string, errorMessage: string): Promise<void>;
+    tryPrettifyJson(jsonStr: string): string;
+    /**
+     * Build model configuration with current training data
+     */
+    buildModelConfig(): {
+        claude: {
+            model: string | null | undefined;
+            system: string;
+            max_tokens: number;
+            temperature: number;
+        };
+        openai: {
+            model: string | null | undefined;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            temperature: number;
+            max_tokens: number;
+        };
+        gemini: {
+            model: string | null | undefined;
+            systemInstruction: string;
+            generationConfig: {
+                temperature: number;
+                maxOutputTokens: number;
+            };
+        };
+    };
+    extractPatterns(data: TrainingDataPaths): Map<string, Set<string>>;
+    updateSystemPrompt(patterns: Map<string, Set<string>>): string;
+    getAvailableModels(): Promise<any[]>;
+    createModelInstance(provider: string, apiKey: string): OpenAI | GoogleGenerativeAI | Anthropic;
+    getModelDisplayName(modelId: string): string;
+    getSingleProviderModels(): Promise<any>;
+    /**
+     * Get complete model state (models, current, capabilities, usage) in one call
+     * This reduces API calls and ensures data consistency
+     */
+    getModelState(): Promise<{
+        models: any[];
+        current: {
+            provider: string;
+            model: string;
+        };
+        capabilities: {
+            supportsImages: string;
+        };
+        usage: {
+            requests: number;
+            totalTokens: number;
+            totalComputeUnits: number;
+            modelSwitches: number;
+            uptime: number;
+            providers: {
+                name: string;
+                requests: number;
+                models: string[];
+            }[];
+        };
+        timestamp: number;
+    }>;
+    /**
+     * Create a model instance for a specific request without changing global state
+     */
+    createModelForRequest(modelSelection: {
+        provider: string;
+        model: string;
+    } | undefined): {
+        model: OpenAI | GoogleGenerativeAI | Anthropic;
+        config: {
+            openai: {
+                model: string;
+                temperature: number;
+                max_tokens: number;
+                messages: {
+                    role: string;
+                    content: string;
+                }[];
+            };
+            claude?: undefined;
+            gemini?: undefined;
+        } | {
+            claude: {
+                model: string;
+                temperature: number;
+                max_tokens: number;
+                system: string;
+                messages: never[];
+            };
+            openai?: undefined;
+            gemini?: undefined;
+        } | {
+            gemini: {
+                model: string;
+                temperature: number;
+                maxOutputTokens: number;
+                systemInstruction: string;
+                generationConfig: {
+                    temperature: number;
+                    maxOutputTokens: number;
+                    candidateCount: number;
+                };
+            };
+            openai?: undefined;
+            claude?: undefined;
+        };
+        provider: string;
+        modelId: string;
+    };
+    /**
+     * Get API key for a specific provider
+     */
+    getApiKeyForProvider(provider: string): string | null | undefined;
+    /**
+     * Build model configuration for a specific request
+     */
+    buildModelConfigForRequest(provider: string, model: string): {
+        openai: {
+            model: string;
+            temperature: number;
+            max_tokens: number;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+        };
+        claude?: undefined;
+        gemini?: undefined;
+    } | {
+        claude: {
+            model: string;
+            temperature: number;
+            max_tokens: number;
+            system: string;
+            messages: never[];
+        };
+        openai?: undefined;
+        gemini?: undefined;
+    } | {
+        gemini: {
+            model: string;
+            temperature: number;
+            maxOutputTokens: number;
+            systemInstruction: string;
+            generationConfig: {
+                temperature: number;
+                maxOutputTokens: number;
+                candidateCount: number;
+            };
+        };
+        openai?: undefined;
+        claude?: undefined;
+    };
+    /**
+     * Get suggestions for a command
+     * @param command - The command to get suggestions for
+     * @param chatHistory - The chat history
+     * @param retryCount - The number of retries
+     * @param chatLevel - The chat level
+     * @param modelSelection - The model selection
+     * @returns The suggestions
+     */
+    getSuggestions(command: string, chatHistory: any[] | undefined, retryCount: number | undefined, chatLevel: 'full' | 'basic' | 'none' | undefined, modelSelection: {
+        provider: string;
+        model: string;
+    } | undefined, context?: string): Promise<Array<{
+        action?: string;
+        path?: string;
+        formState?: Record<string, any>;
+        [key: string]: any;
+    }>>;
+    /**
+     * Check if a response is effectively empty and needs retry
+     */
+    isEmptyResponse(text: string, suggestions?: any[] | null): boolean;
+    /**
+     * Create a retry prompt that encourages more helpful responses
+     */
+    createRetryPrompt(originalCommand: string, retryCount: number): string;
+    streamSuggestions(command: string, userId: string, chatHistory: any[], onData: (data: any) => void, onDone: () => void, onError: (error: Error) => void, images?: any[], retryCount?: number, chatLevel?: 'full' | 'basic' | 'none' | undefined, modelSelection?: {
+        provider: string;
+        model: string;
+        capabilities: {
+            computeWeight: number;
+            imageSupport: boolean;
+        };
+    }, context?: string): Promise<void>;
+    getSuggestionsWithImages(command: string, chatHistory: any[], images: any[], modelSelection?: {
+        provider: string;
+        model: string;
+    } | undefined): Promise<{
+        formState: Record<string, any>;
+        action?: string;
+        actionType: import("../types/types.js").Action;
+        path?: string;
+        queryParams?: Record<string, string>;
+        message?: string;
+        user?: import("../types/types.js").User;
+        initials?: string;
+        color?: string;
+        shortcut?: string;
+        title?: string;
+        description?: string;
+    }[]>;
+    getUsageStats(): {
+        requests: number;
+        totalTokens: number;
+        totalComputeUnits: number;
+        modelSwitches: number;
+        uptime: number;
+        providers: {
+            name: string;
+            requests: number;
+            models: string[];
+        }[];
+    };
+    resetUsageStats(): void;
+    trackRequest(provider: string, tokenCount?: number): void;
+    /**
+     * Helper: Refine fields that require refinement
+     */
+    refineFieldsIfNeeded(suggestions: any, context: any, messages?: any[], provider?: string | null): Promise<any>;
+    /**
+     * Helper: Get raw response content from any provider
+     */
+    getProviderResponse(command: string | ImageContent[], chatHistory: any[] | undefined, messages?: any[], provider?: string | null): Promise<any>;
+    /**
+     * Helper: Process suggestions with full pipeline
+     */
+    processSuggestionsPipeline(suggestions: any[], context: any, messages?: any[], provider?: string | null): Promise<{
+        formState: Record<string, any>;
+        action?: string;
+        actionType: import("../types/types.js").Action;
+        path?: string;
+        queryParams?: Record<string, string>;
+        message?: string;
+        user?: import("../types/types.js").User;
+        initials?: string;
+        color?: string;
+        shortcut?: string;
+        title?: string;
+        description?: string;
+    }[]>;
+}

package/dist/server/training-schema.d.ts

@@ -0,0 +1,17 @@
+import type { TrainingConfig } from '../types/types.js';
+/**
+ * Validate training configuration
+ */
+export declare function validateTrainingConfig(config: TrainingConfig): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Create a normalized training configuration
+ */
+export declare function createTrainingConfig(options?: Partial<TrainingConfig>): TrainingConfig;
+/**
+ * Gets the expected file structure for training data
+ * @returns Expected file structure
+ */
+export declare function getExpectedFileStructure(): Record<string, string>;