chore: update @modelcontextprotocol/sdk to version 1.12.1 (#176 )

feat: add request options configuration to server form (#171 )
feat: enhance DynamicForm to support array and object (#173 )
2025-12-24 02:39:19 -05:00 · 2025-06-10 16:50:28 +08:00 · 2025-06-10 13:51:01 +08:00 · 2025-06-10 13:50:14 +08:00 · 2025-06-07 20:41:51 +08:00 · 2025-06-07 20:36:52 +08:00
25 changed files with 2016 additions and 903 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -20,6 +20,6 @@
      }
    ],
    "@typescript-eslint/no-explicit-any": "off",
-    "no-undef": "off",
+    "no-undef": "off"
  }
 }
--- a/frontend/src/components/MarketServerDetail.tsx
+++ b/frontend/src/components/MarketServerDetail.tsx
@@ -3,10 +3,12 @@ import { useTranslation } from 'react-i18next';
 import { MarketServer, MarketServerInstallation } from '@/types';
 import ServerForm from './ServerForm';

+import { ServerConfig } from '@/types';
+
 interface MarketServerDetailProps {
  server: MarketServer;
  onBack: () => void;
-  onInstall: (server: MarketServer) => void;
+  onInstall: (server: MarketServer, config: ServerConfig) => void;
  installing?: boolean;
  isInstalled?: boolean;
 }
@@ -83,8 +85,8 @@ const MarketServerDetail: React.FC<MarketServerDetailProps> = ({
  const handleSubmit = async (payload: any) => {
    try {
      setError(null);
-      // Pass the server object to the parent component for installation
-      onInstall(server);
+      // Pass the server object and the payload (includes env changes) for installation
+      onInstall(server, payload.config);
      setModalVisible(false);
    } catch (err) {
      console.error('Error installing server:', err);
@@ -294,4 +296,4 @@ const MarketServerDetail: React.FC<MarketServerDetailProps> = ({
  );
 };

-export default MarketServerDetail;
+export default MarketServerDetail;
--- a/frontend/src/components/ServerCard.tsx
+++ b/frontend/src/components/ServerCard.tsx
@@ -11,10 +11,11 @@ interface ServerCardProps {
  server: Server
  onRemove: (serverName: string) => void
  onEdit: (server: Server) => void
-  onToggle?: (server: Server, enabled: boolean) => void
+  onToggle?: (server: Server, enabled: boolean) => Promise<boolean>
+  onRefresh?: () => void
 }

-const ServerCard = ({ server, onRemove, onEdit, onToggle }: ServerCardProps) => {
+const ServerCard = ({ server, onRemove, onEdit, onToggle, onRefresh }: ServerCardProps) => {
  const { t } = useTranslation()
  const { showToast } = useToast()
  const [isExpanded, setIsExpanded] = useState(false)
@@ -102,6 +103,29 @@ const ServerCard = ({ server, onRemove, onEdit, onToggle }: ServerCardProps) =>
    setShowDeleteDialog(false)
  }

+  const handleToolToggle = async (toolName: string, enabled: boolean) => {
+    try {
+      const { toggleTool } = await import('@/services/toolService')
+      const result = await toggleTool(server.name, toolName, enabled)
+
+      if (result.success) {
+        showToast(
+          t(enabled ? 'tool.enableSuccess' : 'tool.disableSuccess', { name: toolName }),
+          'success'
+        )
+        // Trigger refresh to update the tool's state in the UI
+        if (onRefresh) {
+          onRefresh()
+        }
+      } else {
+        showToast(result.error || t('tool.toggleFailed'), 'error')
+      }
+    } catch (error) {
+      console.error('Error toggling tool:', error)
+      showToast(t('tool.toggleFailed'), 'error')
+    }
+  }
+
  return (
    <>
      <div className={`bg-white shadow rounded-lg p-6 mb-6 ${server.enabled === false ? 'opacity-60' : ''}`}>
@@ -217,7 +241,7 @@ const ServerCard = ({ server, onRemove, onEdit, onToggle }: ServerCardProps) =>
            <h6 className={`font-medium ${server.enabled === false ? 'text-gray-600' : 'text-gray-900'} mb-4`}>{t('server.tools')}</h6>
            <div className="space-y-4">
              {server.tools.map((tool, index) => (
-                <ToolCard key={index} server={server.name} tool={tool} />
+                <ToolCard key={index} server={server.name} tool={tool} onToggle={handleToolToggle} />
              ))}
            </div>
          </div>
--- a/frontend/src/components/ServerForm.tsx
+++ b/frontend/src/components/ServerForm.tsx
@@ -41,7 +41,12 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
    args: (initialData && initialData.config && initialData.config.args) || [],
    type: getInitialServerType(), // Initialize the type field
    env: [],
-    headers: []
+    headers: [],
+    options: {
+      timeout: (initialData && initialData.config && initialData.config.options && initialData.config.options.timeout) || 60000,
+      resetTimeoutOnProgress: (initialData && initialData.config && initialData.config.options && initialData.config.options.resetTimeoutOnProgress) || false,
+      maxTotalTimeout: (initialData && initialData.config && initialData.config.options && initialData.config.options.maxTotalTimeout) || undefined,
+    }
  })

  const [envVars, setEnvVars] = useState<EnvVar[]>(
@@ -56,6 +61,7 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
      : [],
  )

+  const [isRequestOptionsExpanded, setIsRequestOptionsExpanded] = useState<boolean>(false)
  const [error, setError] = useState<string | null>(null)
  const isEdit = !!initialData

@@ -66,7 +72,7 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr

  // Transform space-separated arguments string into array
  const handleArgsChange = (value: string) => {
-    let args = value.split(' ').filter((arg) => arg.trim() !== '')
+    const args = value.split(' ').filter((arg) => arg.trim() !== '')
    setFormData({ ...formData, arguments: value, args })
  }

@@ -107,6 +113,17 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
    setHeaderVars(newHeaderVars)
  }

+  // Handle options changes
+  const handleOptionsChange = (field: 'timeout' | 'resetTimeoutOnProgress' | 'maxTotalTimeout', value: number | boolean | undefined) => {
+    setFormData(prev => ({
+      ...prev,
+      options: {
+        ...prev.options,
+        [field]: value
+      }
+    }))
+  }
+
  // Submit handler for server configuration
  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()
@@ -127,6 +144,18 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
        }
      })

+      // Prepare options object, only include defined values
+      const options: any = {}
+      if (formData.options?.timeout && formData.options.timeout !== 60000) {
+        options.timeout = formData.options.timeout
+      }
+      if (formData.options?.resetTimeoutOnProgress) {
+        options.resetTimeoutOnProgress = formData.options.resetTimeoutOnProgress
+      }
+      if (formData.options?.maxTotalTimeout) {
+        options.maxTotalTimeout = formData.options.maxTotalTimeout
+      }
+
      const payload = {
        name: formData.name,
        config: {
@@ -141,7 +170,8 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
              args: formData.args,
              env: Object.keys(env).length > 0 ? env : undefined,
            }
-          )
+          ),
+          ...(Object.keys(options).length > 0 ? { options } : {})
        }
      }

@@ -365,6 +395,75 @@ const ServerForm = ({ onSubmit, onCancel, initialData = null, modalTitle, formEr
          </>
        )}

+        {/* Request Options Configuration */}
+        <div className="mb-4">
+          <div
+            className="flex items-center justify-between cursor-pointer bg-gray-50 hover:bg-gray-100 p-3 rounded border"
+            onClick={() => setIsRequestOptionsExpanded(!isRequestOptionsExpanded)}
+          >
+            <label className="text-gray-700 text-sm font-bold">
+              {t('server.requestOptions')}
+            </label>
+            <span className="text-gray-500 text-sm">
+              {isRequestOptionsExpanded ? '▼' : '▶'}
+            </span>
+          </div>
+
+          {isRequestOptionsExpanded && (
+            <div className="border rounded-b p-4 bg-gray-50 border-t-0">
+              <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                <div>
+                  <label className="block text-gray-600 text-sm font-medium mb-1" htmlFor="timeout">
+                    {t('server.timeout')}
+                  </label>
+                  <input
+                    type="number"
+                    id="timeout"
+                    value={formData.options?.timeout || 60000}
+                    onChange={(e) => handleOptionsChange('timeout', parseInt(e.target.value) || 60000)}
+                    className="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline"
+                    placeholder="30000"
+                    min="1000"
+                    max="300000"
+                  />
+                  <p className="text-xs text-gray-500 mt-1">{t('server.timeoutDescription')}</p>
+                </div>
+
+                <div>
+                  <label className="block text-gray-600 text-sm font-medium mb-1" htmlFor="maxTotalTimeout">
+                    {t('server.maxTotalTimeout')}
+                  </label>
+                  <input
+                    type="number"
+                    id="maxTotalTimeout"
+                    value={formData.options?.maxTotalTimeout || ''}
+                    onChange={(e) => handleOptionsChange('maxTotalTimeout', e.target.value ? parseInt(e.target.value) : undefined)}
+                    className="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline"
+                    placeholder="Optional"
+                    min="1000"
+                  />
+                  <p className="text-xs text-gray-500 mt-1">{t('server.maxTotalTimeoutDescription')}</p>
+                </div>
+              </div>
+
+              <div className="mt-3">
+                <label className="flex items-center">
+                  <input
+                    type="checkbox"
+                    checked={formData.options?.resetTimeoutOnProgress || false}
+                    onChange={(e) => handleOptionsChange('resetTimeoutOnProgress', e.target.checked)}
+                    className="mr-2"
+                  />
+                  <span className="text-gray-600 text-sm">{t('server.resetTimeoutOnProgress')}</span>
+                </label>
+                <p className="text-xs text-gray-500 mt-1 ml-6">
+                  {t('server.resetTimeoutOnProgressDescription')}
+                </p>
+              </div>
+            </div>
+          )}
+        </div>
+
        <div className="flex justify-end mt-6">
          <button
            type="button"
--- a/frontend/src/components/ui/DynamicForm.tsx
+++ b/frontend/src/components/ui/DynamicForm.tsx
@@ -24,6 +24,9 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
  const { t } = useTranslation();
  const [formValues, setFormValues] = useState<Record<string, any>>({});
  const [errors, setErrors] = useState<Record<string, string>>({});
+  const [isJsonMode, setIsJsonMode] = useState<boolean>(false);
+  const [jsonText, setJsonText] = useState<string>('');
+  const [jsonError, setJsonError] = useState<string>('');

  // Convert ToolInputSchema to JsonSchema - memoized to prevent infinite re-renders
  const jsonSchema = useMemo(() => {
@@ -77,7 +80,13 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
          } else if (propSchema.type === 'array') {
            values[key] = [];
          } else if (propSchema.type === 'object') {
-            values[key] = initializeValues(propSchema, fullPath);
+            // For objects with properties, recursively initialize
+            if (propSchema.properties) {
+              values[key] = initializeValues(propSchema, fullPath);
+            } else {
+              // For objects without properties, initialize as empty object
+              values[key] = {};
+            }
          }
        });
      }
@@ -104,6 +113,58 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
    setFormValues(initialValues);
  }, [jsonSchema, storageKey]);

+  // Sync JSON text with form values when switching modes
+  useEffect(() => {
+    if (isJsonMode && Object.keys(formValues).length > 0) {
+      setJsonText(JSON.stringify(formValues, null, 2));
+      setJsonError('');
+    }
+  }, [isJsonMode, formValues]);
+
+  const handleJsonTextChange = (text: string) => {
+    setJsonText(text);
+    setJsonError('');
+
+    try {
+      const parsedJson = JSON.parse(text);
+      setFormValues(parsedJson);
+
+      // Save to localStorage if storageKey is provided
+      if (storageKey) {
+        try {
+          localStorage.setItem(storageKey, JSON.stringify(parsedJson));
+        } catch (error) {
+          console.warn('Failed to save form data to localStorage:', error);
+        }
+      }
+    } catch (error) {
+      setJsonError(t('tool.invalidJsonFormat'));
+    }
+  };
+
+  const switchToJsonMode = () => {
+    setJsonText(JSON.stringify(formValues, null, 2));
+    setJsonError('');
+    setIsJsonMode(true);
+  };
+
+  const switchToFormMode = () => {
+    // Validate JSON before switching
+    if (jsonText.trim()) {
+      try {
+        const parsedJson = JSON.parse(jsonText);
+        setFormValues(parsedJson);
+        setJsonError('');
+        setIsJsonMode(false);
+      } catch (error) {
+        setJsonError(t('tool.fixJsonBeforeSwitching'));
+        return;
+      }
+    } else {
+      setIsJsonMode(false);
+    }
+  };
+
  const handleInputChange = (path: string, value: any) => {
    setFormValues(prev => {
      const newValues = { ...prev };
@@ -140,7 +201,6 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
      });
    }
  };
-
  const validateForm = (): boolean => {
    const newErrors: Record<string, string> = {};

@@ -148,7 +208,7 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
      if (schema.type === 'object' && schema.properties) {
        Object.entries(schema.properties).forEach(([key, propSchema]) => {
          const fullPath = path ? `${path}.${key}` : key;
-          const value = values?.[key];
+          const value = getNestedValue(values, fullPath);

          // Check required fields
          if (schema.required?.includes(key) && (value === undefined || value === null || value === '')) {
@@ -166,6 +226,15 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
              newErrors[fullPath] = `${key} must be an integer`;
            } else if (propSchema.type === 'boolean' && typeof value !== 'boolean') {
              newErrors[fullPath] = `${key} must be a boolean`;
+            } else if (propSchema.type === 'array' && Array.isArray(value)) {
+              // Validate array items
+              if (propSchema.items) {
+                value.forEach((item: any, index: number) => {
+                  if (propSchema.items?.type === 'object' && propSchema.items.properties) {
+                    validateObject(propSchema.items, item, `${fullPath}.${index}`);
+                  }
+                });
+              }
            } else if (propSchema.type === 'object' && typeof value === 'object') {
              validateObject(propSchema, value, fullPath);
            }
@@ -186,18 +255,240 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
    }
  };

+  const getNestedValue = (obj: any, path: string): any => {
+    return path.split('.').reduce((current, key) => current?.[key], obj);
+  };
+
+  const renderObjectField = (key: string, schema: JsonSchema, currentValue: any, onChange: (value: any) => void): React.ReactNode => {
+    const value = currentValue?.[key];
+
+    if (schema.type === 'string') {
+      if (schema.enum) {
+        return (
+          <select
+            value={value || ''}
+            onChange={(e) => onChange(e.target.value)}
+            className="w-full border rounded-md px-2 py-1 text-sm border-gray-300 focus:outline-none focus:ring-1 focus:ring-blue-500"
+          >
+            <option value="">{t('tool.selectOption')}</option>
+            {schema.enum.map((option: any, idx: number) => (
+              <option key={idx} value={option}>
+                {option}
+              </option>
+            ))}
+          </select>
+        );
+      } else {
+        return (
+          <input
+            type="text"
+            value={value || ''}
+            onChange={(e) => onChange(e.target.value)}
+            className="w-full border rounded-md px-2 py-1 text-sm border-gray-300 focus:outline-none focus:ring-1 focus:ring-blue-500"
+            placeholder={schema.description || t('tool.enterKey', { key })}
+          />
+        );
+      }
+    }
+
+    if (schema.type === 'number' || schema.type === 'integer') {
+      return (
+        <input
+          type="number"
+          step={schema.type === 'integer' ? '1' : 'any'}
+          value={value || ''}
+          onChange={(e) => {
+            const val = e.target.value === '' ? '' : schema.type === 'integer' ? parseInt(e.target.value) : parseFloat(e.target.value);
+            onChange(val);
+          }}
+          className="w-full border rounded-md px-2 py-1 text-sm border-gray-300 focus:outline-none focus:ring-1 focus:ring-blue-500"
+        />
+      );
+    }
+
+    if (schema.type === 'boolean') {
+      return (
+        <input
+          type="checkbox"
+          checked={value || false}
+          onChange={(e) => onChange(e.target.checked)}
+          className="h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 rounded"
+        />
+      );
+    }
+
+    // Default to text input
+    return (
+      <input
+        type="text"
+        value={value || ''}
+        onChange={(e) => onChange(e.target.value)}
+        className="w-full border rounded-md px-2 py-1 text-sm border-gray-300 focus:outline-none focus:ring-1 focus:ring-blue-500"
+        placeholder={schema.description || t('tool.enterKey', { key })}
+      />
+    );
+  };
+
  const renderField = (key: string, propSchema: JsonSchema, path: string = ''): React.ReactNode => {
    const fullPath = path ? `${path}.${key}` : key;
-    const value = formValues[key];
-    const error = errors[fullPath];
+    const value = getNestedValue(formValues, fullPath);
+    const error = errors[fullPath];    // Handle array type
+    if (propSchema.type === 'array') {
+      const arrayValue = getNestedValue(formValues, fullPath) || [];

-    if (propSchema.type === 'string') {
+      return (
+        <div key={fullPath} className="mb-6">
+          <label className="block text-sm font-medium text-gray-700 mb-1">
+            {key}
+            {(path ? getNestedValue(jsonSchema, path)?.required?.includes(key) : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
+          </label>
+          {propSchema.description && (
+            <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
+          )}
+
+          <div className="border border-gray-200 rounded-md p-3 bg-gray-50">
+            {arrayValue.map((item: any, index: number) => (
+              <div key={index} className="mb-3 p-3 bg-white border rounded-md">
+                <div className="flex justify-between items-center mb-2">
+                  <span className="text-sm font-medium text-gray-600">{t('tool.item', { index: index + 1 })}</span>
+                  <button
+                    type="button"
+                    onClick={() => {
+                      const newArray = [...arrayValue];
+                      newArray.splice(index, 1);
+                      handleInputChange(fullPath, newArray);
+                    }}
+                    className="text-red-500 hover:text-red-700 text-sm"
+                  >
+                    {t('common.remove')}
+                  </button>
+                </div>
+
+                {propSchema.items?.type === 'string' && propSchema.items.enum ? (
+                  <select
+                    value={item || ''}
+                    onChange={(e) => {
+                      const newArray = [...arrayValue];
+                      newArray[index] = e.target.value;
+                      handleInputChange(fullPath, newArray);
+                    }}
+                    className="w-full border rounded-md px-3 py-2 border-gray-300 focus:outline-none focus:ring-2 focus:ring-blue-500"
+                  >
+                    <option value="">{t('tool.selectOption')}</option>
+                    {propSchema.items.enum.map((option: any, idx: number) => (
+                      <option key={idx} value={option}>
+                        {option}
+                      </option>
+                    ))}
+                  </select>
+                ) : propSchema.items?.type === 'object' && propSchema.items.properties ? (
+                  <div className="space-y-3">
+                    {Object.entries(propSchema.items.properties).map(([objKey, objSchema]) => (
+                      <div key={objKey}>
+                        <label className="block text-xs font-medium text-gray-600 mb-1">
+                          {objKey}
+                          {propSchema.items?.required?.includes(objKey) && <span className="text-red-500 ml-1">*</span>}
+                        </label>
+                        {renderObjectField(objKey, objSchema as JsonSchema, item, (newValue) => {
+                          const newArray = [...arrayValue];
+                          newArray[index] = { ...newArray[index], [objKey]: newValue };
+                          handleInputChange(fullPath, newArray);
+                        })}
+                      </div>
+                    ))}
+                  </div>
+                ) : (
+                  <input
+                    type="text"
+                    value={item || ''}
+                    onChange={(e) => {
+                      const newArray = [...arrayValue];
+                      newArray[index] = e.target.value;
+                      handleInputChange(fullPath, newArray);
+                    }}
+                    className="w-full border rounded-md px-3 py-2 border-gray-300 focus:outline-none focus:ring-2 focus:ring-blue-500"
+                    placeholder={t('tool.enterValue', { type: propSchema.items?.type || 'value' })}
+                  />
+                )}
+              </div>
+            ))}
+
+            <button
+              type="button"
+              onClick={() => {
+                const newItem = propSchema.items?.type === 'object' ? {} : '';
+                handleInputChange(fullPath, [...arrayValue, newItem]);
+              }}
+              className="w-full mt-2 px-3 py-2 text-sm text-blue-600 border border-blue-300 rounded-md hover:bg-blue-50"
+            >
+              {t('tool.addItem', { key })}
+            </button>
+          </div>
+
+          {error && <p className="text-red-500 text-xs mt-1">{error}</p>}
+        </div>
+      );
+    }    // Handle object type
+    if (propSchema.type === 'object') {
+      if (propSchema.properties) {
+        // Object with defined properties - render as nested form
+        return (
+          <div key={fullPath} className="mb-6">
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              {key}
+              {(path ? getNestedValue(jsonSchema, path)?.required?.includes(key) : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
+            </label>
+            {propSchema.description && (
+              <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
+            )}
+
+            <div className="border border-gray-200 rounded-md p-4 bg-gray-50">
+              {Object.entries(propSchema.properties).map(([objKey, objSchema]) => (
+                renderField(objKey, objSchema as JsonSchema, fullPath)
+              ))}
+            </div>
+
+            {error && <p className="text-red-500 text-xs mt-1">{error}</p>}
+          </div>
+        );
+      } else {
+        // Object without defined properties - render as JSON textarea
+        return (
+          <div key={fullPath} className="mb-4">
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              {key}
+              {(path ? getNestedValue(jsonSchema, path)?.required?.includes(key) : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
+              <span className="text-xs text-gray-500 ml-1">(JSON object)</span>
+            </label>
+            {propSchema.description && (
+              <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
+            )}
+            <textarea
+              value={typeof value === 'object' ? JSON.stringify(value, null, 2) : value || '{}'}
+              onChange={(e) => {
+                try {
+                  const parsedValue = JSON.parse(e.target.value);
+                  handleInputChange(fullPath, parsedValue);
+                } catch (err) {
+                  // Keep the string value if it's not valid JSON yet
+                  handleInputChange(fullPath, e.target.value);
+                }
+              }}
+              placeholder={`{\n  "key": "value"\n}`}
+              className={`w-full border rounded-md px-3 py-2 font-mono text-sm ${error ? 'border-red-500' : 'border-gray-300'} focus:outline-none focus:ring-2 focus:ring-blue-500`}
+              rows={4}
+            />
+            {error && <p className="text-red-500 text-xs mt-1">{error}</p>}
+          </div>
+        );
+      }
+    } if (propSchema.type === 'string') {
      if (propSchema.enum) {
        return (
          <div key={fullPath} className="mb-4">
            <label className="block text-sm font-medium text-gray-700 mb-1">
              {key}
-              {jsonSchema.required?.includes(key) && <span className="text-red-500 ml-1">*</span>}
+              {(path ? false : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
            </label>
            {propSchema.description && (
              <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
@@ -222,7 +513,7 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
          <div key={fullPath} className="mb-4">
            <label className="block text-sm font-medium text-gray-700 mb-1">
              {key}
-              {jsonSchema.required?.includes(key) && <span className="text-red-500 ml-1">*</span>}
+              {(path ? false : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
            </label>
            {propSchema.description && (
              <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
@@ -237,14 +528,12 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
          </div>
        );
      }
-    }
-
-    if (propSchema.type === 'number' || propSchema.type === 'integer') {
+    } if (propSchema.type === 'number' || propSchema.type === 'integer') {
      return (
        <div key={fullPath} className="mb-4">
          <label className="block text-sm font-medium text-gray-700 mb-1">
            {key}
-            {jsonSchema.required?.includes(key) && <span className="text-red-500 ml-1">*</span>}
+            {(path ? false : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
          </label>
          {propSchema.description && (
            <p className="text-xs text-gray-500 mb-2">{propSchema.description}</p>
@@ -276,7 +565,7 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
            />
            <label className="ml-2 block text-sm text-gray-700">
              {key}
-              {jsonSchema.required?.includes(key) && <span className="text-red-500 ml-1">*</span>}
+              {(path ? false : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
            </label>
          </div>
          {propSchema.description && (
@@ -285,14 +574,12 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
          {error && <p className="text-red-500 text-xs mt-1">{error}</p>}
        </div>
      );
-    }
-
-    // For other types, show as text input with description
+    }    // For other types, show as text input with description
    return (
      <div key={fullPath} className="mb-4">
        <label className="block text-sm font-medium text-gray-700 mb-1">
          {key}
-          {jsonSchema.required?.includes(key) && <span className="text-red-500 ml-1">*</span>}
+          {(path ? false : jsonSchema.required?.includes(key)) && <span className="text-red-500 ml-1">*</span>}
          <span className="text-xs text-gray-500 ml-1">({propSchema.type})</span>
        </label>
        {propSchema.description && (
@@ -335,28 +622,101 @@ const DynamicForm: React.FC<DynamicFormProps> = ({ schema, onSubmit, onCancel, l
  }

  return (
-    <form onSubmit={handleSubmit} className="space-y-4">
-      {Object.entries(jsonSchema.properties || {}).map(([key, propSchema]) =>
-        renderField(key, propSchema)
-      )}
-
-      <div className="flex justify-end space-x-2 pt-4">
-        <button
-          type="button"
-          onClick={onCancel}
-          className="px-4 py-2 text-sm text-gray-600 bg-gray-100 rounded-md hover:bg-gray-200"
-        >
-          {t('tool.cancel')}
-        </button>
-        <button
-          type="submit"
-          disabled={loading}
-          className="px-4 py-2 text-sm text-white bg-blue-600 rounded-md hover:bg-blue-700 disabled:opacity-50"
-        >
-          {loading ? t('tool.running') : t('tool.runTool')}
-        </button>
+    <div className="space-y-4">
+      {/* Mode Toggle */}
+      <div className="flex justify-between items-center border-b pb-3">
+        <h3 className="text-lg font-medium text-gray-900">{t('tool.parameters')}</h3>
+        <div className="flex space-x-2">
+          <button
+            type="button"
+            onClick={switchToFormMode}
+            className={`px-3 py-1 text-sm rounded-md transition-colors ${!isJsonMode
+              ? 'bg-blue-600 text-white'
+              : 'bg-gray-100 text-gray-600 hover:bg-gray-200'
+              }`}
+          >
+            {t('tool.formMode')}
+          </button>
+          <button
+            type="button"
+            onClick={switchToJsonMode}
+            className={`px-3 py-1 text-sm rounded-md transition-colors ${isJsonMode
+              ? 'bg-blue-600 text-white'
+              : 'bg-gray-100 text-gray-600 hover:bg-gray-200'
+              }`}
+          >
+            {t('tool.jsonMode')}
+          </button>
+        </div>
      </div>
-    </form>
+
+      {/* JSON Mode */}
+      {isJsonMode ? (
+        <div className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-2">
+              {t('tool.jsonConfiguration')}
+            </label>
+            <textarea
+              value={jsonText}
+              onChange={(e) => handleJsonTextChange(e.target.value)}
+              placeholder={`{\n  "key": "value"\n}`}
+              className={`w-full h-64 border rounded-md px-3 py-2 font-mono text-sm resize-y ${jsonError ? 'border-red-500' : 'border-gray-300'
+                } focus:outline-none focus:ring-2 focus:ring-blue-500`}
+            />
+            {jsonError && <p className="text-red-500 text-xs mt-1">{jsonError}</p>}
+          </div>
+
+          <div className="flex justify-end space-x-2 pt-4">
+            <button
+              type="button"
+              onClick={onCancel}
+              className="px-4 py-2 text-sm text-gray-600 bg-gray-100 rounded-md hover:bg-gray-200"
+            >
+              {t('tool.cancel')}
+            </button>
+            <button
+              onClick={() => {
+                try {
+                  const parsedJson = JSON.parse(jsonText);
+                  onSubmit(parsedJson);
+                } catch (error) {
+                  setJsonError(t('tool.invalidJsonFormat'));
+                }
+              }}
+              disabled={loading || !!jsonError}
+              className="px-4 py-2 text-sm text-white bg-blue-600 rounded-md hover:bg-blue-700 disabled:opacity-50"
+            >
+              {loading ? t('tool.running') : t('tool.runTool')}
+            </button>
+          </div>
+        </div>
+      ) : (
+        /* Form Mode */
+        <form onSubmit={handleSubmit} className="space-y-4">
+          {Object.entries(jsonSchema.properties || {}).map(([key, propSchema]) =>
+            renderField(key, propSchema)
+          )}
+
+          <div className="flex justify-end space-x-2 pt-4">
+            <button
+              type="button"
+              onClick={onCancel}
+              className="px-4 py-2 text-sm text-gray-600 bg-gray-100 rounded-md hover:bg-gray-200"
+            >
+              {t('tool.cancel')}
+            </button>
+            <button
+              type="submit"
+              disabled={loading}
+              className="px-4 py-2 text-sm text-white bg-blue-600 rounded-md hover:bg-blue-700 disabled:opacity-50"
+            >
+              {loading ? t('tool.running') : t('tool.runTool')}
+            </button>
+          </div>
+        </form>
+      )}
+    </div>
  );
 };

--- a/frontend/src/components/ui/ToolCard.tsx
+++ b/frontend/src/components/ui/ToolCard.tsx
@@ -1,22 +1,48 @@
-import { useState, useCallback } from 'react'
+import { useState, useCallback, useRef, useEffect } from 'react'
 import { useTranslation } from 'react-i18next'
 import { Tool } from '@/types'
-import { ChevronDown, ChevronRight, Play, Loader } from '@/components/icons/LucideIcons'
-import { callTool, ToolCallResult } from '@/services/toolService'
+import { ChevronDown, ChevronRight, Play, Loader, Edit, Check } from '@/components/icons/LucideIcons'
+import { callTool, ToolCallResult, updateToolDescription } from '@/services/toolService'
+import { Switch } from './ToggleGroup'
 import DynamicForm from './DynamicForm'
 import ToolResult from './ToolResult'

 interface ToolCardProps {
  server: string
  tool: Tool
+  onToggle?: (toolName: string, enabled: boolean) => void
+  onDescriptionUpdate?: (toolName: string, description: string) => void
 }

-const ToolCard = ({ tool, server }: ToolCardProps) => {
+const ToolCard = ({ tool, server, onToggle, onDescriptionUpdate }: ToolCardProps) => {
  const { t } = useTranslation()
  const [isExpanded, setIsExpanded] = useState(false)
  const [showRunForm, setShowRunForm] = useState(false)
  const [isRunning, setIsRunning] = useState(false)
  const [result, setResult] = useState<ToolCallResult | null>(null)
+  const [isEditingDescription, setIsEditingDescription] = useState(false)
+  const [customDescription, setCustomDescription] = useState(tool.description || '')
+  const descriptionInputRef = useRef<HTMLInputElement>(null)
+  const descriptionTextRef = useRef<HTMLSpanElement>(null)
+  const [textWidth, setTextWidth] = useState<number>(0)
+
+  // Focus the input when editing mode is activated
+  useEffect(() => {
+    if (isEditingDescription && descriptionInputRef.current) {
+      descriptionInputRef.current.focus()
+      // Set input width to match text width
+      if (textWidth > 0) {
+        descriptionInputRef.current.style.width = `${textWidth + 20}px` // Add some padding
+      }
+    }
+  }, [isEditingDescription, textWidth])
+
+  // Measure text width when not editing
+  useEffect(() => {
+    if (!isEditingDescription && descriptionTextRef.current) {
+      setTextWidth(descriptionTextRef.current.offsetWidth)
+    }
+  }, [isEditingDescription, customDescription])

  // Generate a unique key for localStorage based on tool name and server
  const getStorageKey = useCallback(() => {
@@ -28,6 +54,49 @@ const ToolCard = ({ tool, server }: ToolCardProps) => {
    localStorage.removeItem(getStorageKey())
  }, [getStorageKey])

+  const handleToggle = (enabled: boolean) => {
+    if (onToggle) {
+      onToggle(tool.name, enabled)
+    }
+  }
+
+  const handleDescriptionEdit = () => {
+    setIsEditingDescription(true)
+  }
+
+  const handleDescriptionSave = async () => {
+    try {
+      const result = await updateToolDescription(server, tool.name, customDescription)
+      if (result.success) {
+        setIsEditingDescription(false)
+        if (onDescriptionUpdate) {
+          onDescriptionUpdate(tool.name, customDescription)
+        }
+      } else {
+        // Revert on error
+        setCustomDescription(tool.description || '')
+        console.error('Failed to update tool description:', result.error)
+      }
+    } catch (error) {
+      console.error('Error updating tool description:', error)
+      setCustomDescription(tool.description || '')
+      setIsEditingDescription(false)
+    }
+  }
+
+  const handleDescriptionChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setCustomDescription(e.target.value)
+  }
+
+  const handleDescriptionKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      handleDescriptionSave()
+    } else if (e.key === 'Escape') {
+      setCustomDescription(tool.description || '')
+      setIsEditingDescription(false)
+    }
+  }
+
  const handleRunTool = async (arguments_: Record<string, any>) => {
    setIsRunning(true)
    try {
@@ -68,13 +137,61 @@ const ToolCard = ({ tool, server }: ToolCardProps) => {
      >
        <div className="flex-1">
          <h3 className="text-lg font-medium text-gray-900">
-            {tool.name}
-            <span className="ml-2 text-sm font-normal text-gray-600">
-              {tool.description || t('tool.noDescription')}
+            {tool.name.replace(server + '-', '')}
+            <span className="ml-2 text-sm font-normal text-gray-600 inline-flex items-center">
+              {isEditingDescription ? (
+                <>
+                  <input
+                    ref={descriptionInputRef}
+                    type="text"
+                    className="px-2 py-1 border border-blue-300 rounded bg-white text-sm"
+                    value={customDescription}
+                    onChange={handleDescriptionChange}
+                    onKeyDown={handleDescriptionKeyDown}
+                    onClick={(e) => e.stopPropagation()}
+                    style={{
+                      minWidth: '100px',
+                      width: textWidth > 0 ? `${textWidth + 20}px` : 'auto'
+                    }}
+                  />
+                  <button
+                    className="ml-2 p-1 text-green-600 hover:text-green-800"
+                    onClick={(e) => {
+                      e.stopPropagation()
+                      handleDescriptionSave()
+                    }}
+                  >
+                    <Check size={16} />
+                  </button>
+                </>
+              ) : (
+                <>
+                  <span ref={descriptionTextRef}>{customDescription || t('tool.noDescription')}</span>
+                  <button
+                    className="ml-2 p-1 text-gray-500 hover:text-blue-600 transition-colors"
+                    onClick={(e) => {
+                      e.stopPropagation()
+                      handleDescriptionEdit()
+                    }}
+                  >
+                    <Edit size={14} />
+                  </button>
+                </>
+              )}
            </span>
          </h3>
        </div>
        <div className="flex items-center space-x-2">
+          <div
+            className="flex items-center space-x-2"
+            onClick={(e) => e.stopPropagation()}
+          >
+            <Switch
+              checked={tool.enabled ?? true}
+              onCheckedChange={handleToggle}
+              disabled={isRunning}
+            />
+          </div>
          <button
            onClick={(e) => {
              e.stopPropagation()
@@ -82,7 +199,7 @@ const ToolCard = ({ tool, server }: ToolCardProps) => {
              setShowRunForm(true)
            }}
            className="flex items-center space-x-1 px-3 py-1 text-sm text-blue-600 bg-blue-50 hover:bg-blue-100 rounded-md transition-colors"
-            disabled={isRunning}
+            disabled={isRunning || !tool.enabled}
          >
            {isRunning ? (
              <Loader size={14} className="animate-spin" />
@@ -112,7 +229,7 @@ const ToolCard = ({ tool, server }: ToolCardProps) => {
          {/* Run Form */}
          {showRunForm && (
            <div className="border border-gray-300 rounded-lg p-4 bg-blue-50">
-              <h4 className="text-sm font-medium text-gray-900 mb-3">{t('tool.runToolWithName', { name: tool.name })}</h4>
+              <h4 className="text-sm font-medium text-gray-900 mb-3">{t('tool.runToolWithName', { name: tool.name.replace(server + '-', '') })}</h4>
              <DynamicForm
                schema={tool.inputSchema || { type: 'object' }}
                onSubmit={handleRunTool}
--- a/frontend/src/hooks/useMarketData.ts
+++ b/frontend/src/hooks/useMarketData.ts
@@ -1,6 +1,6 @@
 import { useState, useEffect, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
-import { MarketServer, ApiResponse } from '@/types';
+import { MarketServer, ApiResponse, ServerConfig } from '@/types';
 import { getApiUrl } from '../utils/runtime';

 export const useMarketData = () => {
@@ -347,7 +347,7 @@ export const useMarketData = () => {

  // Install server to the local environment
  const installServer = useCallback(
-    async (server: MarketServer) => {
+    async (server: MarketServer, customConfig: ServerConfig) => {
      try {
        const installType = server.installations?.npm
          ? 'npm'
@@ -362,13 +362,13 @@ export const useMarketData = () => {

        const installation = server.installations[installType];

-        // Prepare server configuration
+        // Prepare server configuration, merging with customConfig
        const serverConfig = {
          name: server.name,
          config: {
-            command: installation.command,
-            args: installation.args,
-            env: installation.env || {},
+            command: customConfig.command || installation.command || '',
+            args: customConfig.args || installation.args || [],
+            env: { ...installation.env, ...customConfig.env },
          },
        };

--- a/frontend/src/locales/en.json
+++ b/frontend/src/locales/en.json
@@ -99,6 +99,13 @@
    "enabled": "Enabled",
    "enable": "Enable",
    "disable": "Disable",
+    "requestOptions": "Configuration",
+    "timeout": "Request Timeout",
+    "timeoutDescription": "Timeout for requests to the MCP server (ms)",
+    "maxTotalTimeout": "Maximum Total Timeout",
+    "maxTotalTimeoutDescription": "Maximum total timeout for requests sent to the MCP server (ms) (Use with progress notifications)",
+    "resetTimeoutOnProgress": "Reset Timeout on Progress",
+    "resetTimeoutOnProgressDescription": "Reset timeout on progress notifications",
    "remove": "Remove",
    "toggleError": "Failed to toggle server {{serverName}}",
    "alreadyExists": "Server {{serverName}} already exists",
@@ -137,6 +144,7 @@
    "create": "Create",
    "submitting": "Submitting...",
    "delete": "Delete",
+    "remove": "Remove",
    "copy": "Copy",
    "copySuccess": "Copied to clipboard",
    "copyFailed": "Copy failed",
@@ -284,7 +292,20 @@
    "toolResult": "Tool result",
    "noParameters": "This tool does not require any parameters.",
    "selectOption": "Select an option",
-    "enterValue": "Enter {{type}} value"
+    "enterValue": "Enter {{type}} value",
+    "enabled": "Enabled",
+    "enableSuccess": "Tool {{name}} enabled successfully",
+    "disableSuccess": "Tool {{name}} disabled successfully",
+    "toggleFailed": "Failed to toggle tool status",
+    "parameters": "Tool Parameters",
+    "formMode": "Form Mode",
+    "jsonMode": "JSON Mode",
+    "jsonConfiguration": "JSON Configuration",
+    "invalidJsonFormat": "Invalid JSON format",
+    "fixJsonBeforeSwitching": "Please fix JSON format before switching to form mode",
+    "item": "Item {{index}}",
+    "addItem": "Add {{key}} item",
+    "enterKey": "Enter {{key}}"
  },
  "settings": {
    "enableGlobalRoute": "Enable Global Route",
--- a/frontend/src/locales/zh.json
+++ b/frontend/src/locales/zh.json
@@ -99,6 +99,13 @@
    "enabled": "已启用",
    "enable": "启用",
    "disable": "禁用",
+    "requestOptions": "配置",
+    "timeout": "请求超时",
+    "timeoutDescription": "请求超时时间（毫秒）",
+    "maxTotalTimeout": "最大总超时",
+    "maxTotalTimeoutDescription": "无论是否有进度通知的最大总超时时间（毫秒）",
+    "resetTimeoutOnProgress": "收到进度通知时重置超时",
+    "resetTimeoutOnProgressDescription": "适用于发送周期性进度更新的长时间运行操作",
    "remove": "移除",
    "toggleError": "切换服务器 {{serverName}} 状态失败",
    "alreadyExists": "服务器 {{serverName}} 已经存在",
@@ -138,6 +145,7 @@
    "create": "创建",
    "submitting": "提交中...",
    "delete": "删除",
+    "remove": "移除",
    "copy": "复制",
    "copySuccess": "已复制到剪贴板",
    "copyFailed": "复制失败",
@@ -285,7 +293,20 @@
    "toolResult": "工具结果",
    "noParameters": "此工具不需要任何参数。",
    "selectOption": "选择一个选项",
-    "enterValue": "输入{{type}}值"
+    "enterValue": "输入{{type}}值",
+    "enabled": "已启用",
+    "enableSuccess": "工具 {{name}} 启用成功",
+    "disableSuccess": "工具 {{name}} 禁用成功",
+    "toggleFailed": "切换工具状态失败",
+    "parameters": "工具参数",
+    "formMode": "表单模式",
+    "jsonMode": "JSON 模式",
+    "jsonConfiguration": "JSON 配置",
+    "invalidJsonFormat": "无效的 JSON 格式",
+    "fixJsonBeforeSwitching": "请修复 JSON 格式后再切换到表单模式",
+    "item": "项目 {{index}}",
+    "addItem": "添加 {{key}} 项目",
+    "enterKey": "输入 {{key}}"
  },
  "settings": {
    "enableGlobalRoute": "启用全局路由",
--- a/frontend/src/pages/MarketPage.tsx
+++ b/frontend/src/pages/MarketPage.tsx
@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useNavigate, useParams, useLocation } from 'react-router-dom';
-import { MarketServer } from '@/types';
+import { MarketServer, ServerConfig } from '@/types';
 import { useMarketData } from '@/hooks/useMarketData';
 import { useToast } from '@/contexts/ToastContext';
 import MarketServerCard from '@/components/MarketServerCard';
@@ -90,10 +90,11 @@ const MarketPage: React.FC = () => {
    navigate('/market');
  };

-  const handleInstall = async (server: MarketServer) => {
+  const handleInstall = async (server: MarketServer, config: ServerConfig) => {
    try {
      setInstalling(true);
-      const success = await installServer(server);
+      // Pass the server object and the config to the installServer function
+      const success = await installServer(server, config);
      if (success) {
        // Show success message using toast instead of alert
        showToast(t('market.installSuccess', { serverName: server.display_name }), 'success');
@@ -353,4 +354,4 @@ const MarketPage: React.FC = () => {
  );
 };

-export default MarketPage;
+export default MarketPage;
--- a/frontend/src/pages/ServersPage.tsx
+++ b/frontend/src/pages/ServersPage.tsx
@@ -125,6 +125,7 @@ const ServersPage: React.FC = () => {
              onRemove={handleServerRemove}
              onEdit={handleEditClick}
              onToggle={handleServerToggle}
+              onRefresh={triggerRefresh}
            />
          ))}
        </div>
--- a/frontend/src/services/toolService.ts
+++ b/frontend/src/services/toolService.ts
@@ -70,3 +70,90 @@ export const callTool = async (
    };
  }
 };
+
+/**
+ * Toggle a tool's enabled state for a specific server
+ */
+export const toggleTool = async (
+  serverName: string,
+  toolName: string,
+  enabled: boolean,
+): Promise<{ success: boolean; error?: string }> => {
+  try {
+    const token = getToken();
+    if (!token) {
+      throw new Error('Authentication token not found. Please log in.');
+    }
+
+    const response = await fetch(getApiUrl(`/servers/${serverName}/tools/${toolName}/toggle`), {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-auth-token': token,
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({ enabled }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return {
+      success: data.success,
+      error: data.success ? undefined : data.message,
+    };
+  } catch (error) {
+    console.error('Error toggling tool:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred',
+    };
+  }
+};
+
+/**
+ * Update a tool's description for a specific server
+ */
+export const updateToolDescription = async (
+  serverName: string,
+  toolName: string,
+  description: string,
+): Promise<{ success: boolean; error?: string }> => {
+  try {
+    const token = getToken();
+    if (!token) {
+      throw new Error('Authentication token not found. Please log in.');
+    }
+
+    const response = await fetch(
+      getApiUrl(`/servers/${serverName}/tools/${toolName}/description`),
+      {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-auth-token': token,
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ description }),
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return {
+      success: data.success,
+      error: data.success ? undefined : data.message,
+    };
+  } catch (error) {
+    console.error('Error updating tool description:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred',
+    };
+  }
+};
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -67,6 +67,7 @@ export interface Tool {
  name: string;
  description: string;
  inputSchema: ToolInputSchema;
+  enabled?: boolean;
 }

 // Server config types
@@ -78,6 +79,12 @@ export interface ServerConfig {
  env?: Record<string, string>;
  headers?: Record<string, string>;
  enabled?: boolean;
+  tools?: Record<string, { enabled: boolean; description?: string }>; // Tool-specific configurations with enable/disable state and custom descriptions
+  options?: {
+    timeout?: number; // Request timeout in milliseconds
+    resetTimeoutOnProgress?: boolean; // Reset timeout on progress notifications
+    maxTotalTimeout?: number; // Maximum total timeout in milliseconds
+  }; // MCP request options configuration
 }

 // Server types
@@ -114,6 +121,11 @@ export interface ServerFormData {
  type?: 'stdio' | 'sse' | 'streamable-http'; // Added type field
  env: EnvVar[];
  headers: EnvVar[];
+  options?: {
+    timeout?: number;
+    resetTimeoutOnProgress?: boolean;
+    maxTotalTimeout?: number;
+  };
 }

 // Group form data types
--- a/package.json
+++ b/package.json
@@ -41,7 +41,7 @@
  "author": "",
  "license": "ISC",
  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.1",
+    "@modelcontextprotocol/sdk": "^1.12.1",
    "@types/pg": "^8.15.2",
    "bcryptjs": "^3.0.2",
    "dotenv": "^16.3.1",
@@ -77,7 +77,7 @@
    "autoprefixer": "^10.4.21",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
-    "concurrently": "^8.2.2",
+    "concurrently": "^9.1.2",
    "eslint": "^8.50.0",
    "i18next": "^24.2.3",
    "i18next-browser-languagedetector": "^8.0.4",
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/src/config/index.ts
+++ b/src/config/index.ts
@@ -15,18 +15,37 @@ const defaultConfig = {
  mcpHubVersion: getPackageVersion(),
 };

+// Settings cache
+let settingsCache: McpSettings | null = null;
+
 export const getSettingsPath = (): string => {
  return getConfigFilePath('mcp_settings.json', 'Settings');
 };

 export const loadSettings = (): McpSettings => {
+  // If cache exists, return cached data directly
+  if (settingsCache) {
+    return settingsCache;
+  }
+
  const settingsPath = getSettingsPath();
  try {
    const settingsData = fs.readFileSync(settingsPath, 'utf8');
-    return JSON.parse(settingsData);
+    const settings = JSON.parse(settingsData);
+
+    // Update cache
+    settingsCache = settings;
+
+    console.log(`Loaded settings from ${settingsPath}`);
+    return settings;
  } catch (error) {
    console.error(`Failed to load settings from ${settingsPath}:`, error);
-    return { mcpServers: {}, users: [] };
+    const defaultSettings = { mcpServers: {}, users: [] };
+
+    // Cache default settings
+    settingsCache = defaultSettings;
+
+    return defaultSettings;
  }
 };

@@ -34,6 +53,10 @@ export const saveSettings = (settings: McpSettings): boolean => {
  const settingsPath = getSettingsPath();
  try {
    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+
+    // Update cache after successful save
+    settingsCache = settings;
+
    return true;
  } catch (error) {
    console.error(`Failed to save settings to ${settingsPath}:`, error);
@@ -41,6 +64,22 @@ export const saveSettings = (settings: McpSettings): boolean => {
  }
 };

+/**
+ * Clear settings cache, force next loadSettings call to re-read from file
+ */
+export const clearSettingsCache = (): void => {
+  settingsCache = null;
+};
+
+/**
+ * Get current cache status (for debugging)
+ */
+export const getSettingsCacheInfo = (): { hasCache: boolean } => {
+  return {
+    hasCache: settingsCache !== null,
+  };
+};
+
 export const replaceEnvVars = (env: Record<string, any>): Record<string, any> => {
  const res: Record<string, string> = {};
  for (const [key, value] of Object.entries(env)) {
--- a/src/controllers/serverController.ts
+++ b/src/controllers/serverController.ts
@@ -6,6 +6,7 @@ import {
  removeServer,
  updateMcpServer,
  notifyToolChanged,
+  syncToolEmbedding,
  toggleServerStatus,
 } from '../services/mcpService.js';
 import { loadSettings, saveSettings } from '../config/index.js';
@@ -106,6 +107,11 @@ export const createServer = async (req: Request, res: Response): Promise<void> =
      return;
    }

+    // Set default keep-alive interval for SSE servers if not specified
+    if ((config.type === 'sse' || (!config.type && config.url)) && !config.keepAliveInterval) {
+      config.keepAliveInterval = 60000; // Default 60 seconds for SSE servers
+    }
+
    const result = await addServer(name, config);
    if (result.success) {
      notifyToolChanged();
@@ -223,6 +229,11 @@ export const updateServer = async (req: Request, res: Response): Promise<void> =
      return;
    }

+    // Set default keep-alive interval for SSE servers if not specified
+    if ((config.type === 'sse' || (!config.type && config.url)) && !config.keepAliveInterval) {
+      config.keepAliveInterval = 60000; // Default 60 seconds for SSE servers
+    }
+
    const result = await updateMcpServer(name, config);
    if (result.success) {
      notifyToolChanged();
@@ -318,6 +329,136 @@ export const toggleServer = async (req: Request, res: Response): Promise<void> =
  }
 };

+// Toggle tool status for a specific server
+export const toggleTool = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { serverName, toolName } = req.params;
+    const { enabled } = req.body;
+
+    if (!serverName || !toolName) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name and tool name are required',
+      });
+      return;
+    }
+
+    if (typeof enabled !== 'boolean') {
+      res.status(400).json({
+        success: false,
+        message: 'Enabled status must be a boolean',
+      });
+      return;
+    }
+
+    const settings = loadSettings();
+    if (!settings.mcpServers[serverName]) {
+      res.status(404).json({
+        success: false,
+        message: 'Server not found',
+      });
+      return;
+    }
+
+    // Initialize tools config if it doesn't exist
+    if (!settings.mcpServers[serverName].tools) {
+      settings.mcpServers[serverName].tools = {};
+    }
+
+    // Set the tool's enabled state
+    settings.mcpServers[serverName].tools![toolName] = { enabled };
+
+    if (!saveSettings(settings)) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to save settings',
+      });
+      return;
+    }
+
+    // Notify that tools have changed
+    notifyToolChanged();
+
+    res.json({
+      success: true,
+      message: `Tool ${toolName} ${enabled ? 'enabled' : 'disabled'} successfully`,
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Update tool description for a specific server
+export const updateToolDescription = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { serverName, toolName } = req.params;
+    const { description } = req.body;
+
+    if (!serverName || !toolName) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name and tool name are required',
+      });
+      return;
+    }
+
+    if (typeof description !== 'string') {
+      res.status(400).json({
+        success: false,
+        message: 'Description must be a string',
+      });
+      return;
+    }
+
+    const settings = loadSettings();
+    if (!settings.mcpServers[serverName]) {
+      res.status(404).json({
+        success: false,
+        message: 'Server not found',
+      });
+      return;
+    }
+
+    // Initialize tools config if it doesn't exist
+    if (!settings.mcpServers[serverName].tools) {
+      settings.mcpServers[serverName].tools = {};
+    }
+
+    // Set the tool's description
+    if (!settings.mcpServers[serverName].tools![toolName]) {
+      settings.mcpServers[serverName].tools![toolName] = { enabled: true };
+    }
+
+    settings.mcpServers[serverName].tools![toolName].description = description;
+
+    if (!saveSettings(settings)) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to save settings',
+      });
+      return;
+    }
+
+    // Notify that tools have changed
+    notifyToolChanged();
+
+    syncToolEmbedding(serverName, toolName);
+
+    res.json({
+      success: true,
+      message: `Tool ${toolName} description updated successfully`,
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
 export const updateSystemConfig = (req: Request, res: Response): void => {
  try {
    const { routing, install, smartRouting } = req.body;
--- a/src/db/connection.ts
+++ b/src/db/connection.ts
@@ -1,13 +1,9 @@
 import 'reflect-metadata'; // Ensure reflect-metadata is imported here too
 import { DataSource, DataSourceOptions } from 'typeorm';
-import dotenv from 'dotenv';
-import dotenvExpand from 'dotenv-expand';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import entities from './entities/index.js';
 import { registerPostgresVectorType } from './types/postgresVectorType.js';
 import { VectorEmbeddingSubscriber } from './subscribers/VectorEmbeddingSubscriber.js';
-import { loadSettings } from '../config/index.js';
+import { getSmartRoutingConfig } from '../utils/smartRouting.js';

 // Helper function to create required PostgreSQL extensions
 const createRequiredExtensions = async (dataSource: DataSource): Promise<void> => {
@@ -30,23 +26,7 @@ const createRequiredExtensions = async (dataSource: DataSource): Promise<void> =

 // Get database URL from smart routing config or fallback to environment variable
 const getDatabaseUrl = (): string => {
-  try {
-    const settings = loadSettings();
-    const smartRouting = settings.systemConfig?.smartRouting;
-
-    // Use smart routing dbUrl if smart routing is enabled and dbUrl is configured
-    if (smartRouting?.enabled && smartRouting?.dbUrl) {
-      console.log('Using smart routing database URL');
-      return smartRouting.dbUrl;
-    }
-  } catch (error) {
-    console.warn(
-      'Failed to load settings for smart routing database URL, falling back to environment variable:',
-      error,
-    );
-  }
-
-  return '';
+  return getSmartRoutingConfig().dbUrl;
 };

 // Default database configuration
@@ -59,7 +39,10 @@ const defaultConfig: DataSourceOptions = {
 };

 // AppDataSource is the TypeORM data source
-let AppDataSource = new DataSource(defaultConfig);
+let appDataSource = new DataSource(defaultConfig);
+
+// Global promise to track initialization status
+let initializationPromise: Promise<DataSource> | null = null;

 // Function to create a new DataSource with updated configuration
 export const updateDataSourceConfig = (): DataSource => {
@@ -69,31 +52,36 @@ export const updateDataSourceConfig = (): DataSource => {
  };

  // If the configuration has changed, we need to create a new DataSource
-  const currentUrl = (AppDataSource.options as any).url;
+  const currentUrl = (appDataSource.options as any).url;
  if (currentUrl !== newConfig.url) {
    console.log('Database URL configuration changed, updating DataSource...');
-    AppDataSource = new DataSource(newConfig);
+    appDataSource = new DataSource(newConfig);
+    // Reset initialization promise when configuration changes
+    initializationPromise = null;
  }

-  return AppDataSource;
+  return appDataSource;
 };

 // Get the current AppDataSource instance
 export const getAppDataSource = (): DataSource => {
-  return AppDataSource;
+  return appDataSource;
 };

 // Reconnect database with updated configuration
 export const reconnectDatabase = async (): Promise<DataSource> => {
  try {
    // Close existing connection if it exists
-    if (AppDataSource.isInitialized) {
+    if (appDataSource.isInitialized) {
      console.log('Closing existing database connection...');
-      await AppDataSource.destroy();
+      await appDataSource.destroy();
    }

+    // Reset initialization promise to allow fresh initialization
+    initializationPromise = null;
+
    // Update configuration and reconnect
-    AppDataSource = updateDataSourceConfig();
+    appDataSource = updateDataSourceConfig();
    return await initializeDatabase();
  } catch (error) {
    console.error('Error during database reconnection:', error);
@@ -101,26 +89,54 @@ export const reconnectDatabase = async (): Promise<DataSource> => {
  }
 };

-// Initialize database connection
+// Initialize database connection with concurrency control
 export const initializeDatabase = async (): Promise<DataSource> => {
+  // If initialization is already in progress, wait for it to complete
+  if (initializationPromise) {
+    console.log('Database initialization already in progress, waiting for completion...');
+    return initializationPromise;
+  }
+
+  // If already initialized, return the existing instance
+  if (appDataSource.isInitialized) {
+    console.log('Database already initialized, returning existing instance');
+    return Promise.resolve(appDataSource);
+  }
+
+  // Create a new initialization promise
+  initializationPromise = performDatabaseInitialization();
+
+  try {
+    const result = await initializationPromise;
+    console.log('Database initialization completed successfully');
+    return result;
+  } catch (error) {
+    // Reset the promise on error so initialization can be retried
+    initializationPromise = null;
+    console.error('Database initialization failed:', error);
+    throw error;
+  }
+};
+
+// Internal function to perform the actual database initialization
+const performDatabaseInitialization = async (): Promise<DataSource> => {
  try {
    // Update configuration before initializing
-    AppDataSource = updateDataSourceConfig();
+    appDataSource = updateDataSourceConfig();

-    if (!AppDataSource.isInitialized) {
+    if (!appDataSource.isInitialized) {
      console.log('Initializing database connection...');
      // Register the vector type with TypeORM
-      await AppDataSource.initialize();
-      registerPostgresVectorType(AppDataSource);
+      await appDataSource.initialize();
+      registerPostgresVectorType(appDataSource);

      // Create required PostgreSQL extensions
-      await createRequiredExtensions(AppDataSource);
+      await createRequiredExtensions(appDataSource);

      // Set up vector column and index with a more direct approach
      try {
-
        // Check if table exists first
-        const tableExists = await AppDataSource.query(`
+        const tableExists = await appDataSource.query(`
          SELECT EXISTS (
            SELECT FROM information_schema.tables 
            WHERE table_schema = 'public'
@@ -134,7 +150,7 @@ export const initializeDatabase = async (): Promise<DataSource> => {

          // Step 1: Drop any existing index on the column
          try {
-            await AppDataSource.query(`DROP INDEX IF EXISTS idx_vector_embeddings_embedding;`);
+            await appDataSource.query(`DROP INDEX IF EXISTS idx_vector_embeddings_embedding;`);
          } catch (dropError: any) {
            console.warn('Note: Could not drop existing index:', dropError.message);
          }
@@ -142,14 +158,14 @@ export const initializeDatabase = async (): Promise<DataSource> => {
          // Step 2: Alter column type to vector (if it's not already)
          try {
            // Check column type first
-            const columnType = await AppDataSource.query(`
+            const columnType = await appDataSource.query(`
              SELECT data_type FROM information_schema.columns
              WHERE table_schema = 'public' AND table_name = 'vector_embeddings'
              AND column_name = 'embedding';
            `);

            if (columnType.length > 0 && columnType[0].data_type !== 'vector') {
-              await AppDataSource.query(`
+              await appDataSource.query(`
                ALTER TABLE vector_embeddings 
                ALTER COLUMN embedding TYPE vector USING embedding::vector;
              `);
@@ -163,7 +179,7 @@ export const initializeDatabase = async (): Promise<DataSource> => {
          // Step 3: Try to create appropriate indices
          try {
            // First, let's check if there are any records to determine the dimensions
-            const records = await AppDataSource.query(`
+            const records = await appDataSource.query(`
              SELECT dimensions FROM vector_embeddings LIMIT 1;
            `);

@@ -177,13 +193,13 @@ export const initializeDatabase = async (): Promise<DataSource> => {

            // Set the vector dimensions explicitly only if table has data
            if (records && records.length > 0) {
-              await AppDataSource.query(`
+              await appDataSource.query(`
                ALTER TABLE vector_embeddings 
                ALTER COLUMN embedding TYPE vector(${dimensions});
              `);

              // Now try to create the index
-              await AppDataSource.query(`
+              await appDataSource.query(`
                CREATE INDEX IF NOT EXISTS idx_vector_embeddings_embedding 
                ON vector_embeddings USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
              `);
@@ -199,7 +215,7 @@ export const initializeDatabase = async (): Promise<DataSource> => {

            try {
              // Try HNSW index instead
-              await AppDataSource.query(`
+              await appDataSource.query(`
                CREATE INDEX IF NOT EXISTS idx_vector_embeddings_embedding 
                ON vector_embeddings USING hnsw (embedding vector_cosine_ops);
              `);
@@ -210,7 +226,7 @@ export const initializeDatabase = async (): Promise<DataSource> => {

              try {
                // Create a basic GIN index as last resort
-                await AppDataSource.query(`
+                await appDataSource.query(`
                  CREATE INDEX IF NOT EXISTS idx_vector_embeddings_embedding 
                  ON vector_embeddings USING gin (embedding);
                `);
@@ -235,12 +251,11 @@ export const initializeDatabase = async (): Promise<DataSource> => {

      // Run one final setup check after schema synchronization is done
      if (defaultConfig.synchronize) {
-        setTimeout(async () => {
-          try {
-            console.log('Running final vector configuration check...');
+        try {
+          console.log('Running final vector configuration check...');

-            // Try setup again with the same code from above
-            const tableExists = await AppDataSource.query(`
+          // Try setup again with the same code from above
+          const tableExists = await appDataSource.query(`
              SELECT EXISTS (
                SELECT FROM information_schema.tables 
                WHERE table_schema = 'public'
@@ -248,64 +263,60 @@ export const initializeDatabase = async (): Promise<DataSource> => {
              );
            `);

-            if (tableExists[0].exists) {
-              console.log('Vector embeddings table found, checking configuration...');
+          if (tableExists[0].exists) {
+            console.log('Vector embeddings table found, checking configuration...');

-              // Get the dimension size first
-              try {
-                // Try to get dimensions from an existing record
-                const records = await AppDataSource.query(`
+            // Get the dimension size first
+            try {
+              // Try to get dimensions from an existing record
+              const records = await appDataSource.query(`
                  SELECT dimensions FROM vector_embeddings LIMIT 1;
                `);

-                // Only proceed if we have existing data, otherwise let vector service handle it
-                if (records && records.length > 0 && records[0].dimensions) {
-                  const dimensions = records[0].dimensions;
-                  console.log(`Found vector dimension from database: ${dimensions}`);
+              // Only proceed if we have existing data, otherwise let vector service handle it
+              if (records && records.length > 0 && records[0].dimensions) {
+                const dimensions = records[0].dimensions;
+                console.log(`Found vector dimension from database: ${dimensions}`);

-                  // Ensure column type is vector with explicit dimensions
-                  await AppDataSource.query(`
+                // Ensure column type is vector with explicit dimensions
+                await appDataSource.query(`
                    ALTER TABLE vector_embeddings 
                    ALTER COLUMN embedding TYPE vector(${dimensions});
                  `);
-                  console.log('Vector embedding column type updated in final check.');
+                console.log('Vector embedding column type updated in final check.');

-                  // One more attempt at creating the index with dimensions
-                  try {
-                    // Drop existing index if any
-                    await AppDataSource.query(`
+                // One more attempt at creating the index with dimensions
+                try {
+                  // Drop existing index if any
+                  await appDataSource.query(`
                      DROP INDEX IF EXISTS idx_vector_embeddings_embedding;
                    `);

-                    // Create new index with proper dimensions
-                    await AppDataSource.query(`
+                  // Create new index with proper dimensions
+                  await appDataSource.query(`
                      CREATE INDEX idx_vector_embeddings_embedding 
                      ON vector_embeddings USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
                    `);
-                    console.log('Created IVFFlat index in final check.');
-                  } catch (indexError: any) {
-                    console.warn(
-                      'Final index creation attempt did not succeed:',
-                      indexError.message,
-                    );
-                    console.warn('Using basic lookup without vector index.');
-                  }
-                } else {
-                  console.log(
-                    'No existing vector data found, vector dimensions will be configured by vector service.',
-                  );
+                  console.log('Created IVFFlat index in final check.');
+                } catch (indexError: any) {
+                  console.warn('Final index creation attempt did not succeed:', indexError.message);
+                  console.warn('Using basic lookup without vector index.');
                }
-              } catch (setupError: any) {
-                console.warn('Vector setup in final check failed:', setupError.message);
+              } else {
+                console.log(
+                  'No existing vector data found, vector dimensions will be configured by vector service.',
+                );
              }
+            } catch (setupError: any) {
+              console.warn('Vector setup in final check failed:', setupError.message);
            }
-          } catch (error: any) {
-            console.warn('Post-initialization vector setup failed:', error.message);
          }
-        }, 3000); // Give synchronize some time to complete
+        } catch (error: any) {
+          console.warn('Post-initialization vector setup failed:', error.message);
+        }
      }
    }
-    return AppDataSource;
+    return appDataSource;
  } catch (error) {
    console.error('Error during database initialization:', error);
    throw error;
@@ -314,18 +325,18 @@ export const initializeDatabase = async (): Promise<DataSource> => {

 // Get database connection status
 export const isDatabaseConnected = (): boolean => {
-  return AppDataSource.isInitialized;
+  return appDataSource.isInitialized;
 };

 // Close database connection
 export const closeDatabase = async (): Promise<void> => {
-  if (AppDataSource.isInitialized) {
-    await AppDataSource.destroy();
+  if (appDataSource.isInitialized) {
+    await appDataSource.destroy();
    console.log('Database connection closed.');
  }
 };

 // Export AppDataSource for backward compatibility
-export { AppDataSource };
+export const AppDataSource = appDataSource;

 export default getAppDataSource;
--- a/src/middlewares/index.ts
+++ b/src/middlewares/index.ts
@@ -1,37 +1,8 @@
 import express, { Request, Response, NextFunction } from 'express';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import fs from 'fs';
 import { auth } from './auth.js';
 import { initializeDefaultUser } from '../models/User.js';
 import config from '../config/index.js';

-// Create __dirname equivalent for ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Try to find the correct frontend file path
-const findFrontendPath = (): string => {
-  // First try development environment path
-  const devPath = path.join(dirname(__dirname), 'frontend', 'dist', 'index.html');
-  if (fs.existsSync(devPath)) {
-    return path.join(dirname(__dirname), 'frontend', 'dist');
-  }
-
-  // Try npm/npx installed path (remove /dist directory)
-  const npmPath = path.join(dirname(dirname(__dirname)), 'frontend', 'dist', 'index.html');
-  if (fs.existsSync(npmPath)) {
-    return path.join(dirname(dirname(__dirname)), 'frontend', 'dist');
-  }
-
-  // If none of the above paths exist, return the most reasonable default path and log a warning
-  console.warn('Warning: Could not locate frontend files. Using default path.');
-  return path.join(dirname(__dirname), 'frontend', 'dist');
-};
-
-const frontendPath = findFrontendPath();
-
 export const errorHandler = (
  err: Error,
  _req: Request,
@@ -52,6 +23,7 @@ export const initMiddlewares = (app: express.Application): void => {
  app.use((req, res, next) => {
    const basePath = config.basePath;
    // Only apply JSON parsing for API and auth routes, not for SSE or message endpoints
+    // TODO exclude sse responses by mcp endpoint
    if (
      req.path !== `${basePath}/sse` &&
      !req.path.startsWith(`${basePath}/sse/`) &&
--- a/src/routes/index.ts
+++ b/src/routes/index.ts
@@ -8,6 +8,8 @@ import {
  updateServer,
  deleteServer,
  toggleServer,
+  toggleTool,
+  updateToolDescription,
  updateSystemConfig,
 } from '../controllers/serverController.js';
 import {
@@ -46,6 +48,8 @@ export const initRoutes = (app: express.Application): void => {
  router.put('/servers/:name', updateServer);
  router.delete('/servers/:name', deleteServer);
  router.post('/servers/:name/toggle', toggleServer);
+  router.post('/servers/:serverName/tools/:toolName/toggle', toggleTool);
+  router.put('/servers/:serverName/tools/:toolName/description', updateToolDescription);
  router.put('/system-config', updateSystemConfig);

  // Group management routes
--- a/src/services/mcpService.ts
+++ b/src/services/mcpService.ts
@@ -4,7 +4,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { ServerInfo, ServerConfig } from '../types/index.js';
+import { ServerInfo, ServerConfig, ToolInfo } from '../types/index.js';
 import { loadSettings, saveSettings, expandEnvVars, replaceEnvVars } from '../config/index.js';
 import config from '../config/index.js';
 import { getGroup } from './sseService.js';
@@ -13,6 +13,38 @@ import { saveToolsAsVectorEmbeddings, searchToolsByVector } from './vectorSearch

 const servers: { [sessionId: string]: Server } = {};

+// Helper function to set up keep-alive ping for SSE connections
+const setupKeepAlive = (serverInfo: ServerInfo, serverConfig: ServerConfig): void => {
+  // Only set up keep-alive for SSE connections
+  if (!(serverInfo.transport instanceof SSEClientTransport)) {
+    return;
+  }
+
+  // Clear any existing interval first
+  if (serverInfo.keepAliveIntervalId) {
+    clearInterval(serverInfo.keepAliveIntervalId);
+  }
+
+  // Use configured interval or default to 60 seconds for SSE
+  const interval = serverConfig.keepAliveInterval || 60000;
+
+  serverInfo.keepAliveIntervalId = setInterval(async () => {
+    try {
+      if (serverInfo.client && serverInfo.status === 'connected') {
+        await serverInfo.client.ping();
+        console.log(`Keep-alive ping successful for server: ${serverInfo.name}`);
+      }
+    } catch (error) {
+      console.warn(`Keep-alive ping failed for server ${serverInfo.name}:`, error);
+      // TODO Consider handling reconnection logic here if needed
+    }
+  }, interval);
+
+  console.log(
+    `Keep-alive ping set up for server ${serverInfo.name} with interval ${interval / 1000} seconds`,
+  );
+};
+
 export const initUpstreamServers = async (): Promise<void> => {
  await registerAllTools(true);
 };
@@ -50,6 +82,21 @@ export const notifyToolChanged = async () => {
  });
 };

+export const syncToolEmbedding = async (serverName: string, toolName: string) => {
+  const serverInfo = getServerByName(serverName);
+  if (!serverInfo) {
+    console.warn(`Server not found: ${serverName}`);
+    return;
+  }
+  const tool = serverInfo.tools.find((t) => t.name === toolName);
+  if (!tool) {
+    console.warn(`Tool not found: ${toolName} on server: ${serverName}`);
+    return;
+  }
+  // Save tool as vector embedding for search
+  saveToolsAsVectorEmbeddings(serverName, [tool]);
+};
+
 // Store all server information
 let serverInfos: ServerInfo[] = [];

@@ -171,14 +218,27 @@ export const initializeClientsFromSettings = (isInit: boolean): ServerInfo[] =>
        },
      },
    );
-    const timeout = isInit ? Number(config.initTimeout) : Number(config.timeout);
+
+    const initRequestOptions = isInit
+      ? {
+          timeout: Number(config.initTimeout) || 60000,
+        }
+      : undefined;
+
+    // Get request options from server configuration, with fallbacks
+    const serverRequestOptions = conf.options || {};
+    const requestOptions = {
+      timeout: serverRequestOptions.timeout || 60000,
+      resetTimeoutOnProgress: serverRequestOptions.resetTimeoutOnProgress || false,
+      maxTotalTimeout: serverRequestOptions.maxTotalTimeout,
+    };
+
    client
-      .connect(transport, { timeout: timeout })
+      .connect(transport, initRequestOptions || requestOptions)
      .then(() => {
        console.log(`Successfully connected client for server: ${name}`);
-
        client
-          .listTools({}, { timeout: timeout })
+          .listTools({}, initRequestOptions || requestOptions)
          .then((tools) => {
            console.log(`Successfully listed ${tools.tools.length} tools for server: ${name}`);
            const serverInfo = getServerByName(name);
@@ -188,28 +248,18 @@ export const initializeClientsFromSettings = (isInit: boolean): ServerInfo[] =>
            }

            serverInfo.tools = tools.tools.map((tool) => ({
-              name: tool.name,
+              name: `${name}-${tool.name}`,
              description: tool.description || '',
              inputSchema: tool.inputSchema || {},
            }));
            serverInfo.status = 'connected';
            serverInfo.error = null;

-            // Save tools as vector embeddings for search (only when smart routing is enabled)
-            if (serverInfo.tools.length > 0) {
-              try {
-                const settings = loadSettings();
-                const smartRoutingEnabled = settings.systemConfig?.smartRouting?.enabled || false;
-                if (smartRoutingEnabled) {
-                  console.log(
-                    `Smart routing enabled - saving vector embeddings for server ${name}`,
-                  );
-                  saveToolsAsVectorEmbeddings(name, serverInfo.tools);
-                }
-              } catch (vectorError) {
-                console.warn(`Failed to save vector embeddings for server ${name}:`, vectorError);
-              }
-            }
+            // Set up keep-alive ping for SSE connections
+            setupKeepAlive(serverInfo, conf);
+
+            // Save tools as vector embeddings for search
+            saveToolsAsVectorEmbeddings(name, serverInfo.tools);
          })
          .catch((error) => {
            console.error(
@@ -239,6 +289,7 @@ export const initializeClientsFromSettings = (isInit: boolean): ServerInfo[] =>
      tools: [],
      client,
      transport,
+      options: requestOptions,
      createTime: Date.now(),
    });
    console.log(`Initialized client for server: ${name}`);
@@ -258,11 +309,22 @@ export const getServersInfo = (): Omit<ServerInfo, 'client' | 'transport'>[] =>
  const infos = serverInfos.map(({ name, status, tools, createTime, error }) => {
    const serverConfig = settings.mcpServers[name];
    const enabled = serverConfig ? serverConfig.enabled !== false : true;
+
+    // Add enabled status and custom description to each tool
+    const toolsWithEnabled = tools.map((tool) => {
+      const toolConfig = serverConfig?.tools?.[tool.name];
+      return {
+        ...tool,
+        description: toolConfig?.description || tool.description, // Use custom description if available
+        enabled: toolConfig?.enabled !== false, // Default to true if not explicitly disabled
+      };
+    });
+
    return {
      name,
      status,
      error,
-      tools,
+      tools: toolsWithEnabled,
      createTime,
      enabled,
    };
@@ -279,6 +341,23 @@ const getServerByName = (name: string): ServerInfo | undefined => {
  return serverInfos.find((serverInfo) => serverInfo.name === name);
 };

+// Filter tools by server configuration
+const filterToolsByConfig = (serverName: string, tools: ToolInfo[]): ToolInfo[] => {
+  const settings = loadSettings();
+  const serverConfig = settings.mcpServers[serverName];
+
+  if (!serverConfig || !serverConfig.tools) {
+    // If no tool configuration exists, all tools are enabled by default
+    return tools;
+  }
+
+  return tools.filter((tool) => {
+    const toolConfig = serverConfig.tools?.[tool.name];
+    // If tool is not in config, it's enabled by default
+    return toolConfig?.enabled !== false;
+  });
+};
+
 // Get server by tool name
 const getServerByTool = (toolName: string): ServerInfo | undefined => {
  return serverInfos.find((serverInfo) => serverInfo.tools.some((tool) => tool.name === toolName));
@@ -359,6 +438,13 @@ export const updateMcpServer = async (
 function closeServer(name: string) {
  const serverInfo = serverInfos.find((serverInfo) => serverInfo.name === name);
  if (serverInfo && serverInfo.client && serverInfo.transport) {
+    // Clear keep-alive interval if exists
+    if (serverInfo.keepAliveIntervalId) {
+      clearInterval(serverInfo.keepAliveIntervalId);
+      serverInfo.keepAliveIntervalId = undefined;
+      console.log(`Cleared keep-alive interval for server: ${serverInfo.name}`);
+    }
+
    serverInfo.client.close();
    serverInfo.transport.close();
    console.log(`Closed client and transport for server: ${serverInfo.name}`);
@@ -489,7 +575,21 @@ Available servers: ${serversList}`;
  const allTools = [];
  for (const serverInfo of allServerInfos) {
    if (serverInfo.tools && serverInfo.tools.length > 0) {
-      allTools.push(...serverInfo.tools);
+      // Filter tools based on server configuration and apply custom descriptions
+      const enabledTools = filterToolsByConfig(serverInfo.name, serverInfo.tools);
+
+      // Apply custom descriptions from configuration
+      const settings = loadSettings();
+      const serverConfig = settings.mcpServers[serverInfo.name];
+      const toolsWithCustomDescriptions = enabledTools.map((tool) => {
+        const toolConfig = serverConfig?.tools?.[tool.name];
+        return {
+          ...tool,
+          description: toolConfig?.description || tool.description, // Use custom description if available
+        };
+      });
+
+      allTools.push(...toolsWithCustomDescriptions);
    }
  }

@@ -530,30 +630,54 @@ export const handleCallToolRequest = async (request: any, extra: any) => {
      const searchResults = await searchToolsByVector(query, limitNum, thresholdNum, servers);
      console.log(`Search results: ${JSON.stringify(searchResults)}`);
      // Find actual tool information from serverInfos by serverName and toolName
-      const tools = searchResults.map((result) => {
-        // Find the server in serverInfos
-        const server = serverInfos.find(
-          (serverInfo) =>
-            serverInfo.name === result.serverName &&
-            serverInfo.status === 'connected' &&
-            serverInfo.enabled !== false,
-        );
-        if (server && server.tools && server.tools.length > 0) {
-          // Find the tool in server.tools
-          const actualTool = server.tools.find((tool) => tool.name === result.toolName);
-          if (actualTool) {
-            // Return the actual tool info from serverInfos
-            return actualTool;
-          }
-        }
+      const tools = searchResults
+        .map((result) => {
+          // Find the server in serverInfos
+          const server = serverInfos.find(
+            (serverInfo) =>
+              serverInfo.name === result.serverName &&
+              serverInfo.status === 'connected' &&
+              serverInfo.enabled !== false,
+          );
+          if (server && server.tools && server.tools.length > 0) {
+            // Find the tool in server.tools
+            const actualTool = server.tools.find((tool) => tool.name === result.toolName);
+            if (actualTool) {
+              // Check if the tool is enabled in configuration
+              const enabledTools = filterToolsByConfig(server.name, [actualTool]);
+              if (enabledTools.length > 0) {
+                // Apply custom description from configuration
+                const settings = loadSettings();
+                const serverConfig = settings.mcpServers[server.name];
+                const toolConfig = serverConfig?.tools?.[actualTool.name];

-        // Fallback to search result if server or tool not found
-        return {
-          name: result.toolName,
-          description: result.description || '',
-          inputSchema: result.inputSchema || {},
-        };
-      });
+                // Return the actual tool info from serverInfos with custom description
+                return {
+                  ...actualTool,
+                  description: toolConfig?.description || actualTool.description,
+                };
+              }
+            }
+          }
+
+          // Fallback to search result if server or tool not found or disabled
+          return {
+            name: result.toolName,
+            description: result.description || '',
+            inputSchema: result.inputSchema || {},
+          };
+        })
+        .filter((tool) => {
+          // Additional filter to remove tools that are disabled
+          if (tool.name) {
+            const serverName = searchResults.find((r) => r.toolName === tool.name)?.serverName;
+            if (serverName) {
+              const enabledTools = filterToolsByConfig(serverName, [tool as ToolInfo]);
+              return enabledTools.length > 0;
+            }
+          }
+          return true; // Keep fallback results
+        });

      // Add usage guidance to the response
      const response = {
@@ -586,14 +710,12 @@ export const handleCallToolRequest = async (request: any, extra: any) => {

    // Special handling for call_tool
    if (request.params.name === 'call_tool') {
-      const { toolName, arguments: toolArgs = {} } = request.params.arguments || {};
-
+      let { toolName } = request.params.arguments || {};
      if (!toolName) {
        throw new Error('toolName parameter is required');
      }

-      // arguments parameter is now optional
-
+      const { arguments: toolArgs = {} } = request.params.arguments || {};
      let targetServerInfo: ServerInfo | undefined;
      if (extra && extra.server) {
        targetServerInfo = getServerByName(extra.server);
@@ -631,10 +753,17 @@ export const handleCallToolRequest = async (request: any, extra: any) => {
        `Invoking tool '${toolName}' on server '${targetServerInfo.name}' with arguments: ${JSON.stringify(finalArgs)}`,
      );

-      const result = await client.callTool({
-        name: toolName,
-        arguments: finalArgs,
-      });
+      toolName = toolName.startsWith(`${targetServerInfo.name}-`)
+        ? toolName.replace(`${targetServerInfo.name}-`, '')
+        : toolName;
+      const result = await client.callTool(
+        {
+          name: toolName,
+          arguments: finalArgs,
+        },
+        undefined,
+        targetServerInfo.options || {},
+      );

      console.log(`Tool invocation result: ${JSON.stringify(result)}`);
      return result;
@@ -649,7 +778,11 @@ export const handleCallToolRequest = async (request: any, extra: any) => {
    if (!client) {
      throw new Error(`Client not found for server: ${request.params.name}`);
    }
-    const result = await client.callTool(request.params);
+
+    request.params.name = request.params.name.startsWith(`${serverInfo.name}-`)
+      ? request.params.name.replace(`${serverInfo.name}-`, '')
+      : request.params.name;
+    const result = await client.callTool(request.params, undefined, serverInfo.options || {});
    console.log(`Tool call result: ${JSON.stringify(result)}`);
    return result;
  } catch (error) {
--- a/src/services/sseService.ts
+++ b/src/services/sseService.ts
@@ -6,6 +6,7 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { deleteMcpServer, getMcpServer } from './mcpService.js';
 import { loadSettings } from '../config/index.js';
+import config from '../config/index.js';

 const transports: { [sessionId: string]: { transport: Transport; group: string } } = {};

@@ -58,7 +59,7 @@ export const handleSseConnection = async (req: Request, res: Response): Promise<
    return;
  }

-  const transport = new SSEServerTransport('/messages', res);
+  const transport = new SSEServerTransport(`${config.basePath}/messages`, res);
  transports[transport.sessionId] = { transport, group: group };

  res.on('close', () => {
@@ -108,7 +109,10 @@ export const handleSseMessage = async (req: Request, res: Response): Promise<voi
 export const handleMcpPostRequest = async (req: Request, res: Response): Promise<void> => {
  const sessionId = req.headers['mcp-session-id'] as string | undefined;
  const group = req.params.group;
-  console.log(`Handling MCP post request for sessionId: ${sessionId} and group: ${group}`);
+  const body = req.body;
+  console.log(
+    `Handling MCP post request for sessionId: ${sessionId} and group: ${group} with body: ${JSON.stringify(body)}`,
+  );
  // Check bearer auth
  if (!validateBearerAuth(req)) {
    res.status(401).send('Bearer authentication required or invalid token');
--- a/src/services/vectorSearchService.ts
+++ b/src/services/vectorSearchService.ts
@@ -2,45 +2,17 @@ import { getRepositoryFactory } from '../db/index.js';
 import { VectorEmbeddingRepository } from '../db/repositories/index.js';
 import { ToolInfo } from '../types/index.js';
 import { getAppDataSource, initializeDatabase } from '../db/connection.js';
-import { loadSettings } from '../config/index.js';
+import { getSmartRoutingConfig } from '../utils/smartRouting.js';
 import OpenAI from 'openai';

 // Get OpenAI configuration from smartRouting settings or fallback to environment variables
 const getOpenAIConfig = () => {
-  try {
-    const settings = loadSettings();
-    const smartRouting = settings.systemConfig?.smartRouting;
-
-    return {
-      apiKey: smartRouting?.openaiApiKey || process.env.OPENAI_API_KEY,
-      baseURL:
-        smartRouting?.openaiApiBaseUrl ||
-        process.env.OPENAI_API_BASE_URL ||
-        'https://api.openai.com/v1',
-      embeddingModel:
-        smartRouting?.openaiApiEmbeddingModel ||
-        process.env.OPENAI_API_EMBEDDING_MODEL ||
-        'text-embedding-3-small',
-    };
-  } catch (error) {
-    console.warn(
-      'Failed to load smartRouting settings, falling back to environment variables:',
-      error,
-    );
-    return {
-      apiKey: '',
-      baseURL: 'https://api.openai.com/v1',
-      embeddingModel: 'text-embedding-3-small',
-    };
-  }
-};
-
-// Environment variables for embedding configuration
-const EMBEDDING_ENV = {
-  // The embedding model to use - default to OpenAI but allow BAAI/BGE models
-  MODEL: process.env.EMBEDDING_MODEL || getOpenAIConfig().embeddingModel,
-  // Detect if using a BGE model from the environment variable
-  IS_BGE_MODEL: !!(process.env.EMBEDDING_MODEL && process.env.EMBEDDING_MODEL.includes('bge')),
+  const smartRoutingConfig = getSmartRoutingConfig();
+  return {
+    apiKey: smartRoutingConfig.openaiApiKey,
+    baseURL: smartRoutingConfig.openaiApiBaseUrl,
+    embeddingModel: smartRoutingConfig.openaiApiEmbeddingModel,
+  };
 };

 // Constants for embedding models
@@ -221,6 +193,16 @@ export const saveToolsAsVectorEmbeddings = async (
  tools: ToolInfo[],
 ): Promise<void> => {
  try {
+    if (tools.length === 0) {
+      console.warn(`No tools to save for server: ${serverName}`);
+      return;
+    }
+
+    const smartRoutingConfig = getSmartRoutingConfig();
+    if (!smartRoutingConfig.enabled) {
+      return;
+    }
+
    const config = getOpenAIConfig();
    const vectorRepository = getRepositoryFactory(
      'vectorEmbeddings',
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -2,6 +2,8 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { SmartRoutingConfig } from '../utils/smartRouting.js';

 // User interface
 export interface IUser {
@@ -90,13 +92,7 @@ export interface McpSettings {
      pythonIndexUrl?: string; // Python package repository URL (UV_DEFAULT_INDEX)
      npmRegistry?: string; // NPM registry URL (npm_config_registry)
    };
-    smartRouting?: {
-      enabled?: boolean; // Controls whether smart routing is enabled
-      dbUrl?: string; // Database URL for smart routing
-      openaiApiBaseUrl?: string; // OpenAI API base URL
-      openaiApiKey?: string; // OpenAI API key
-      openaiApiEmbeddingModel?: string; // OpenAI API embedding model
-    };
+    smartRouting?: SmartRoutingConfig;
    // Add other system configuration sections here in the future
  };
 }
@@ -110,6 +106,9 @@ export interface ServerConfig {
  env?: Record<string, string>; // Environment variables
  headers?: Record<string, string>; // HTTP headers for SSE/streamable-http servers
  enabled?: boolean; // Flag to enable/disable the server
+  keepAliveInterval?: number; // Keep-alive ping interval in milliseconds (default: 60000ms for SSE servers)
+  tools?: Record<string, { enabled: boolean; description?: string }>; // Tool-specific configurations with enable/disable state and custom descriptions
+  options?: Partial<Pick<RequestOptions, 'timeout' | 'resetTimeoutOnProgress' | 'maxTotalTimeout'>>; // MCP request options configuration
 }

 // Information about a server's status and tools
@@ -120,8 +119,10 @@ export interface ServerInfo {
  tools: ToolInfo[]; // List of tools available on the server
  client?: Client; // Client instance for communication
  transport?: SSEClientTransport | StdioClientTransport | StreamableHTTPClientTransport; // Transport mechanism used
+  options?: RequestOptions; // Options for requests
  createTime: number; // Timestamp of when the server was created
  enabled?: boolean; // Flag to indicate if the server is enabled
+  keepAliveIntervalId?: NodeJS.Timeout; // Timer ID for keep-alive ping interval
 }

 // Details about a tool available on the server
@@ -129,6 +130,7 @@ export interface ToolInfo {
  name: string; // Name of the tool
  description: string; // Brief description of the tool
  inputSchema: Record<string, unknown>; // Input schema for the tool
+  enabled?: boolean; // Whether the tool is enabled (optional, defaults to true)
 }

 // Standardized API response structure
--- a/src/utils/smartRouting.ts
+++ b/src/utils/smartRouting.ts
@@ -0,0 +1,143 @@
+import { loadSettings, expandEnvVars } from '../config/index.js';
+
+/**
+ * Smart routing configuration interface
+ */
+export interface SmartRoutingConfig {
+  enabled: boolean;
+  dbUrl: string;
+  openaiApiBaseUrl: string;
+  openaiApiKey: string;
+  openaiApiEmbeddingModel: string;
+}
+
+/**
+ * Gets the complete smart routing configuration from environment variables and settings.
+ *
+ * Priority order for each setting:
+ * 1. Specific environment variables (ENABLE_SMART_ROUTING, SMART_ROUTING_ENABLED, etc.)
+ * 2. Generic environment variables (OPENAI_API_KEY, DATABASE_URL, etc.)
+ * 3. Settings configuration (systemConfig.smartRouting)
+ * 4. Default values
+ *
+ * @returns {SmartRoutingConfig} Complete smart routing configuration
+ */
+export function getSmartRoutingConfig(): SmartRoutingConfig {
+  let settings = loadSettings();
+  const smartRoutingSettings: Partial<SmartRoutingConfig> =
+    settings.systemConfig?.smartRouting || {};
+
+  return {
+    // Enabled status - check multiple environment variables
+    enabled: getConfigValue(
+      [process.env.SMART_ROUTING_ENABLED],
+      smartRoutingSettings.enabled,
+      false,
+      parseBooleanEnvVar,
+    ),
+
+    // Database configuration
+    dbUrl: getConfigValue([process.env.DB_URL], smartRoutingSettings.dbUrl, '', expandEnvVars),
+
+    // OpenAI API configuration
+    openaiApiBaseUrl: getConfigValue(
+      [process.env.OPENAI_API_BASE_URL],
+      smartRoutingSettings.openaiApiBaseUrl,
+      'https://api.openai.com/v1',
+      expandEnvVars,
+    ),
+
+    openaiApiKey: getConfigValue(
+      [process.env.OPENAI_API_KEY],
+      smartRoutingSettings.openaiApiKey,
+      '',
+      expandEnvVars,
+    ),
+
+    openaiApiEmbeddingModel: getConfigValue(
+      [process.env.OPENAI_API_EMBEDDING_MODEL],
+      smartRoutingSettings.openaiApiEmbeddingModel,
+      'text-embedding-3-small',
+      expandEnvVars,
+    ),
+  };
+}
+
+/**
+ * Gets a configuration value with priority order: environment variables > settings > default.
+ *
+ * @param {(string | undefined)[]} envVars - Array of environment variable names to check in order
+ * @param {any} settingsValue - Value from settings configuration
+ * @param {any} defaultValue - Default value to use if no other value is found
+ * @param {Function} transformer - Function to transform the final value to the correct type
+ * @returns {any} The configuration value with the appropriate transformation applied
+ */
+function getConfigValue<T>(
+  envVars: (string | undefined)[],
+  settingsValue: any,
+  defaultValue: T,
+  transformer: (value: any) => T,
+): T {
+  // Check environment variables in order
+  for (const envVar of envVars) {
+    if (envVar !== undefined && envVar !== null && envVar !== '') {
+      try {
+        return transformer(envVar);
+      } catch (error) {
+        console.warn(`Failed to transform environment variable "${envVar}":`, error);
+        continue;
+      }
+    }
+  }
+
+  // Check settings value
+  if (settingsValue !== undefined && settingsValue !== null) {
+    try {
+      return transformer(settingsValue);
+    } catch (error) {
+      console.warn('Failed to transform settings value:', error);
+    }
+  }
+
+  // Return default value
+  return defaultValue;
+}
+
+/**
+ * Parses a string environment variable value to a boolean.
+ * Supports common boolean representations: true/false, 1/0, yes/no, on/off
+ *
+ * @param {string} value - The environment variable value to parse
+ * @returns {boolean} The parsed boolean value
+ */
+function parseBooleanEnvVar(value: string): boolean {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  const normalized = value.toLowerCase().trim();
+
+  // Handle common truthy values
+  if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
+    return true;
+  }
+
+  // Handle common falsy values
+  if (
+    normalized === 'false' ||
+    normalized === '0' ||
+    normalized === 'no' ||
+    normalized === 'off' ||
+    normalized === ''
+  ) {
+    return false;
+  }
+
+  // Default to false for unrecognized values
+  console.warn(`Unrecognized boolean value for smart routing: "${value}", defaulting to false`);
+  return false;
+}
Author	SHA1	Message	Date
samanhappy	40af398f68	chore: update @modelcontextprotocol/sdk to version 1.12.1 (#176 )	2025-06-10 16:50:28 +08:00
samanhappy	4726f00a22	feat: add request options configuration to server form (#171 )	2025-06-10 13:51:01 +08:00
samanhappy	77f64b7b98	feat: enhance DynamicForm to support array and object (#173 ) Co-authored-by: samanhappy@qq.com <my6051199>	2025-06-10 13:50:14 +08:00
samanhappy	d9cbc5381a	feat: implement keep-alive functionality for SSE connections (#166 ) Co-authored-by: samanhappy@qq.com <my6051199>	2025-06-07 20:41:51 +08:00
samanhappy	56c6447469	feat: implement settings cache with load, save, clear, and status functions (#167 )	2025-06-07 20:36:52 +08:00
samanhappy	f8149c4b0b	fix: update SSE transport path to use basePath from config (#165 ) Co-authored-by: samanhappy@qq.com <my6051199>	2025-06-07 20:35:20 +08:00
purefkh	e259f30539	fix: save user config when install mcp server from market (#168 )	2025-06-07 20:34:51 +08:00
samanhappy	3a421bc476	fix: update tool name formatting from '/' to '-' in ToolCard and mcpService (#164 ) Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-06-05 15:34:49 +08:00
samanhappy	503b60edb7	feat: add tool management features including toggle and description updates (#163 ) Co-authored-by: samanhappy@qq.com <my6051199>	2025-06-04 16:03:45 +08:00
dependabot[bot]	4039a85ee1	chore(deps-dev): bump concurrently from 8.2.2 to 9.1.2 (#156 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-02 19:49:58 +08:00
dependabot[bot]	3a83b83a9e	chore(deps-dev): bump @vitejs/plugin-react from 4.4.1 to 4.5.0 (#160 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-02 19:47:04 +08:00
samanhappy	c1621805de	fix: expand environment variables in database and OpenAI configuration (#162 )	2025-06-02 19:46:39 +08:00