machinaos 0.0.1

package/client/src/factories/baseChatModelFactory.ts

@@ -0,0 +1,256 @@
+// Base Chat Model Factory - Standardized node definition generator
+import {
+  INodeTypeDescription,
+  NodeConnectionType,
+  INodeProperties
+} from '../types/INodeProperties';
+
+// ============================================================================
+// BASE CHAT MODEL CONFIGURATION INTERFACE
+// ============================================================================
+
+export interface ChatModelConfig {
+  providerId: string;
+  displayName: string;
+  icon: string;
+  color: string;
+  description: string;
+  nodeName?: string;
+  models: Array<{
+    name: string;
+    value: string;
+    maxTokens?: number;
+  }>;
+  parameters: INodeProperties[];
+}
+
+// ============================================================================
+// BASE CHAT MODEL FACTORY FUNCTION
+// ============================================================================
+
+export function createBaseChatModel(config: ChatModelConfig): INodeTypeDescription {
+  return {
+    displayName: `${config.displayName} Chat Model`,
+    name: config.nodeName || `${config.providerId}ChatModel`,
+    icon: config.icon,
+    group: ['model'],
+    version: 1,
+    subtitle: '={{$parameter["model"]}}',
+    description: config.description,
+    defaults: {
+      name: `${config.displayName} Chat Model`,
+      color: config.color
+    },
+    inputs: [{
+      name: 'prompt',
+      displayName: 'Prompt',
+      type: 'string' as NodeConnectionType,
+      description: 'Input prompt or message for the AI model',
+      required: false
+    }],
+    outputs: [{
+      name: 'model',
+      displayName: 'Model',
+      type: 'ai' as NodeConnectionType,
+      description: `${config.displayName} configuration for AI agents`,
+      dataStructure: {
+        properties: {
+          provider: {
+            type: 'string',
+            description: `Model provider (${config.providerId})`,
+            required: true
+          },
+          model: {
+            type: 'string',
+            description: 'Model name',
+            required: true
+          },
+          apiKey: {
+            type: 'string',
+            description: `${config.displayName} API key`,
+            required: true
+          },
+          temperature: {
+            type: 'number',
+            description: 'Sampling temperature'
+          },
+          maxTokens: {
+            type: 'number',
+            description: 'Maximum response tokens'
+          },
+          topP: {
+            type: 'number',
+            description: 'Top-p sampling parameter'
+          }
+        }
+      }
+    }],
+    properties: [
+      {
+        displayName: 'Model',
+        name: 'model',
+        type: 'string',
+        default: '',
+        required: true,
+        placeholder: `Select a ${config.displayName} model...`,
+        description: `${config.displayName} model to use (configure API key in Credentials)`,
+        typeOptions: {
+          dynamicOptions: true
+        }
+      },
+      {
+        displayName: 'Prompt',
+        name: 'prompt',
+        type: 'string',
+        default: '{{ $json.message }}',
+        required: true,
+        typeOptions: {
+          rows: 4
+        },
+        description: 'The message to send to the AI model',
+        placeholder: 'Enter your prompt or use template variables...'
+      },
+      {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+          {
+            displayName: 'System Message',
+            name: 'systemMessage',
+            type: 'string',
+            default: '',
+            typeOptions: {
+              rows: 3
+            },
+            description: 'System message to define AI behavior and personality'
+          },
+          ...config.parameters
+        ] as any
+      }
+    ]
+  };
+}
+
+// ============================================================================
+// STANDARD PARAMETER SETS
+// ============================================================================
+
+export const STANDARD_PARAMETERS = {
+  temperature: {
+    displayName: 'Temperature',
+    name: 'temperature',
+    type: 'number' as const,
+    default: 0.7,
+    typeOptions: { minValue: 0, maxValue: 2, numberStepSize: 0.1 },
+    description: 'Controls randomness in responses'
+  },
+
+  maxTokens: {
+    displayName: 'Maximum Tokens',
+    name: 'maxTokens',
+    type: 'number' as const,
+    default: 1000,
+    typeOptions: { minValue: 1, maxValue: 8192 },
+    description: 'Maximum number of tokens to generate'
+  },
+
+  topP: {
+    displayName: 'Top P',
+    name: 'topP',
+    type: 'number' as const,
+    default: 1,
+    typeOptions: { minValue: 0, maxValue: 1, numberStepSize: 0.1 },
+    description: 'Controls diversity via nucleus sampling'
+  },
+
+  topK: {
+    displayName: 'Top K',
+    name: 'topK',
+    type: 'number' as const,
+    default: 40,
+    typeOptions: { minValue: 1, maxValue: 100 },
+    description: 'Limits token selection to top K candidates'
+  },
+
+  frequencyPenalty: {
+    displayName: 'Frequency Penalty',
+    name: 'frequencyPenalty',
+    type: 'number' as const,
+    default: 0,
+    typeOptions: { minValue: -2, maxValue: 2, numberStepSize: 0.1 },
+    description: 'Penalty for frequency of token usage'
+  },
+
+  presencePenalty: {
+    displayName: 'Presence Penalty',
+    name: 'presencePenalty',
+    type: 'number' as const,
+    default: 0,
+    typeOptions: { minValue: -2, maxValue: 2, numberStepSize: 0.1 },
+    description: 'Penalty for presence of tokens'
+  },
+
+  // Thinking/Reasoning parameters
+  thinkingEnabled: {
+    displayName: 'Thinking/Reasoning Mode',
+    name: 'thinkingEnabled',
+    type: 'boolean' as const,
+    default: false,
+    description: 'Enable extended thinking for supported models'
+  },
+
+  thinkingBudget: {
+    displayName: 'Thinking Budget (Tokens)',
+    name: 'thinkingBudget',
+    type: 'number' as const,
+    default: 2048,
+    typeOptions: { minValue: 1024, maxValue: 16000 },
+    description: 'Maximum tokens for thinking (Claude, Gemini 2.5)',
+    displayOptions: { show: { thinkingEnabled: [true] } }
+  },
+
+  reasoningEffort: {
+    displayName: 'Reasoning Effort',
+    name: 'reasoningEffort',
+    type: 'options' as const,
+    options: [
+      { name: 'Minimal', value: 'minimal' },
+      { name: 'Low', value: 'low' },
+      { name: 'Medium', value: 'medium' },
+      { name: 'High', value: 'high' }
+    ],
+    default: 'medium',
+    description: 'Reasoning effort level (OpenAI o-series)',
+    displayOptions: { show: { thinkingEnabled: [true] } }
+  },
+
+  thinkingLevel: {
+    displayName: 'Thinking Level',
+    name: 'thinkingLevel',
+    type: 'options' as const,
+    options: [
+      { name: 'Low', value: 'low' },
+      { name: 'Medium', value: 'medium' },
+      { name: 'High', value: 'high' }
+    ],
+    default: 'medium',
+    description: 'Thinking depth (Gemini 3+)',
+    displayOptions: { show: { thinkingEnabled: [true] } }
+  },
+
+  reasoningFormat: {
+    displayName: 'Reasoning Format',
+    name: 'reasoningFormat',
+    type: 'options' as const,
+    options: [
+      { name: 'Parsed (show reasoning)', value: 'parsed' },
+      { name: 'Hidden (final answer only)', value: 'hidden' }
+    ],
+    default: 'parsed',
+    description: 'How to return reasoning content (Groq)',
+    displayOptions: { show: { thinkingEnabled: [true] } }
+  }
+};

package/client/src/hooks/useAndroidOperations.ts

@@ -0,0 +1,164 @@
+/**
+ * useAndroidOperations Hook - WebSocket-based Android device operations
+ *
+ * Provides Android device management and service execution via WebSocket.
+ * This replaces REST-based Android API calls for real-time operations.
+ */
+
+import { useCallback, useState } from 'react';
+import { useWebSocket } from '../contexts/WebSocketContext';
+
+export interface AndroidDevice {
+  id: string;
+  model?: string;
+  state?: string;
+}
+
+export interface AndroidActionResult {
+  success: boolean;
+  result?: any;
+  error?: string;
+}
+
+export interface UseAndroidOperationsResult {
+  // Get list of connected devices
+  getDevices: () => Promise<AndroidDevice[]>;
+
+  // Setup Android device connection
+  setupDevice: (
+    connectionType: 'local' | 'remote',
+    deviceId?: string,
+    websocketUrl?: string,
+    port?: number
+  ) => Promise<AndroidActionResult>;
+
+  // Execute Android service action
+  executeAction: (
+    serviceId: string,
+    action: string,
+    parameters: Record<string, any>,
+    deviceId?: string
+  ) => Promise<AndroidActionResult>;
+
+  // State
+  isExecuting: boolean;
+  lastError: string | null;
+  isConnected: boolean;
+
+  // Android status from WebSocket
+  androidStatus: {
+    connected: boolean;
+    device_id: string | null;
+    connected_devices: string[];
+    connection_type: string | null;
+  };
+}
+
+export const useAndroidOperations = (): UseAndroidOperationsResult => {
+  const {
+    getAndroidDevices: wsGetDevices,
+    setupAndroidDevice: wsSetupDevice,
+    executeAndroidAction: wsExecuteAction,
+    androidStatus,
+    isConnected
+  } = useWebSocket();
+
+  const [isExecuting, setIsExecuting] = useState(false);
+  const [lastError, setLastError] = useState<string | null>(null);
+
+  /**
+   * Get list of connected Android devices
+   */
+  const getDevices = useCallback(async (): Promise<AndroidDevice[]> => {
+    try {
+      const devices = await wsGetDevices();
+      return devices.map((id: string) => ({ id }));
+    } catch (error: any) {
+      console.warn('Failed to get Android devices:', error);
+      setLastError(error.message);
+      return [];
+    }
+  }, [wsGetDevices]);
+
+  /**
+   * Setup Android device connection
+   */
+  const setupDevice = useCallback(async (
+    connectionType: 'local' | 'remote',
+    deviceId?: string,
+    websocketUrl?: string,
+    _port: number = 8888  // Port passed to backend via wsSetupDevice
+  ): Promise<AndroidActionResult> => {
+    setIsExecuting(true);
+    setLastError(null);
+
+    try {
+      const result = await wsSetupDevice(connectionType, deviceId, websocketUrl);
+
+      if (!result.success) {
+        setLastError(result.error || 'Setup failed');
+      }
+
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.error
+      };
+    } catch (error: any) {
+      const errorMsg = error.message || 'Device setup failed';
+      setLastError(errorMsg);
+      return {
+        success: false,
+        error: errorMsg
+      };
+    } finally {
+      setIsExecuting(false);
+    }
+  }, [wsSetupDevice]);
+
+  /**
+   * Execute Android service action
+   */
+  const executeAction = useCallback(async (
+    serviceId: string,
+    action: string,
+    parameters: Record<string, any>,
+    deviceId?: string
+  ): Promise<AndroidActionResult> => {
+    setIsExecuting(true);
+    setLastError(null);
+
+    try {
+      const result = await wsExecuteAction(serviceId, action, parameters, deviceId);
+
+      if (!result.success) {
+        setLastError(result.error || 'Action failed');
+      }
+
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.error
+      };
+    } catch (error: any) {
+      const errorMsg = error.message || 'Action execution failed';
+      setLastError(errorMsg);
+      return {
+        success: false,
+        error: errorMsg
+      };
+    } finally {
+      setIsExecuting(false);
+    }
+  }, [wsExecuteAction]);
+
+  return {
+    getDevices,
+    setupDevice,
+    executeAction,
+    isExecuting,
+    lastError,
+    isConnected,
+    androidStatus
+  };
+};

package/client/src/hooks/useApiKeyValidation.ts

@@ -0,0 +1,107 @@
+import { useState, useEffect, useCallback } from 'react';
+import { notification } from 'antd';
+import { useApiKeys } from './useApiKeys';
+
+export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
+
+interface UseApiKeyValidationProps {
+  provider?: string;
+  onSuccess?: (models: string[]) => void;
+}
+
+export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidationProps) => {
+  const [status, setStatus] = useState<ValidationStatus>('idle');
+  const [hasStoredKeyState, setHasStoredKeyState] = useState(false);
+
+  // Use WebSocket-based API key management
+  const {
+    validateApiKey: wsValidateApiKey,
+    getStoredApiKey: wsGetStoredApiKey,
+    hasStoredKey: wsHasStoredKey,
+    removeApiKey: wsRemoveApiKey,
+    getStoredModels: wsGetStoredModels
+  } = useApiKeys();
+
+  // Check for existing key on mount
+  useEffect(() => {
+    if (!provider) return;
+
+    const checkStoredKey = async () => {
+      try {
+        const hasKey = await wsHasStoredKey(provider);
+        if (hasKey) {
+          setHasStoredKeyState(true);
+          setStatus('valid');
+
+          // Try to get models if there's a stored key
+          const models = await wsGetStoredModels(provider);
+          if (models?.length && onSuccess) {
+            onSuccess(models);
+          }
+        }
+      } catch (error) {
+        console.warn('Error checking stored key:', error);
+      }
+    };
+
+    checkStoredKey();
+  }, [provider, onSuccess, wsHasStoredKey, wsGetStoredModels]);
+
+  const validate = useCallback(async (apiKey: string) => {
+    if (!provider || !apiKey.trim()) {
+      notification.error({ message: 'Please enter an API key' });
+      return;
+    }
+
+    setStatus('validating');
+
+    try {
+      const result = await wsValidateApiKey(provider, apiKey.trim());
+
+      if (result.isValid) {
+        setStatus('valid');
+        setHasStoredKeyState(true);
+        notification.success({ message: 'API key validated successfully!' });
+
+        if (result.models?.length && onSuccess) {
+          onSuccess(result.models);
+        }
+      } else {
+        setStatus('invalid');
+        notification.error({ message: result.error || 'Invalid API key' });
+      }
+    } catch (error: any) {
+      setStatus('invalid');
+      notification.error({ message: error.message || 'Validation failed' });
+    }
+  }, [provider, onSuccess, wsValidateApiKey]);
+
+  const clear = useCallback(async () => {
+    if (!provider) return;
+
+    try {
+      await wsRemoveApiKey(provider);
+      setHasStoredKeyState(false);
+      setStatus('idle');
+      notification.success({ message: 'API key cleared' });
+    } catch (error) {
+      notification.error({ message: 'Failed to clear API key' });
+    }
+  }, [provider, wsRemoveApiKey]);
+
+  const getStoredKey = useCallback(async () => {
+    if (!provider) return null;
+    return await wsGetStoredApiKey(provider);
+  }, [provider, wsGetStoredApiKey]);
+
+  return {
+    status,
+    hasStoredKey: hasStoredKeyState,
+    validate,
+    clear,
+    getStoredKey,
+    isValidating: status === 'validating',
+    isValid: status === 'valid',
+    isInvalid: status === 'invalid'
+  };
+};