using official mcp sdk and added description fields

Author: priyanshu.solanki

apps/sim/app/api/mcp/serve/[serverId]/sse/route.ts

@@ -6,10 +6,24 @@ import { createLogger } from '@/lib/logs/console/logger'
 import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
 import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
 import { sanitizeToolName } from '@/lib/mcp/workflow-tool-schema'
-import { hasValidStartBlock } from '@/lib/workflows/triggers/trigger-utils'
+import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import { hasValidStartBlockInState } from '@/lib/workflows/triggers/trigger-utils'
 
 const logger = createLogger('WorkflowMcpToolsAPI')
 
+/**
+ * Check if a workflow has a valid start block by loading from database
+ */
+async function hasValidStartBlock(workflowId: string): Promise<boolean> {
+  try {
+    const normalizedData = await loadWorkflowFromNormalizedTables(workflowId)
+    return hasValidStartBlockInState(normalizedData)
+  } catch (error) {
+    logger.warn('Error checking for start block:', error)
+    return false
+  }
+}
+
 export const dynamic = 'force-dynamic'
 
 interface RouteParams {

apps/sim/app/api/mcp/workflow-servers/[id]/tools/route.ts

@@ -3,16 +3,30 @@ import { and, desc, eq } from 'drizzle-orm'
 import type { NextRequest } from 'next/server'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { createLogger } from '@/lib/logs/console/logger'
+import {
+  extractInputFormatFromBlocks,
+  generateToolInputSchema,
+} from '@/lib/mcp/workflow-tool-schema'
 import { deployWorkflow, loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import { hasValidStartBlockInState } from '@/lib/workflows/triggers/trigger-utils'
 import { validateWorkflowPermissions } from '@/lib/workflows/utils'
-import {
-  hasValidStartBlock,
-  isValidStartBlockType,
-} from '@/lib/workflows/triggers/trigger-utils'
 import { createErrorResponse, createSuccessResponse } from '@/app/api/workflows/utils'
 
 const logger = createLogger('WorkflowDeployAPI')
 
+/**
+ * Check if a workflow has a valid start block by loading from database
+ */
+async function hasValidStartBlock(workflowId: string): Promise<boolean> {
+  try {
+    const normalizedData = await loadWorkflowFromNormalizedTables(workflowId)
+    return hasValidStartBlockInState(normalizedData)
+  } catch (error) {
+    logger.warn('Error checking for start block:', error)
+    return false
+  }
+}
+
 export const dynamic = 'force-dynamic'
 export const runtime = 'nodejs'
 
@@ -26,58 +40,12 @@ async function generateMcpToolSchema(workflowId: string): Promise<Record<string,
       return { type: 'object', properties: {} }
     }
 
-    // Find the start block
-    const startBlock = Object.values(normalizedData.blocks).find((block: any) => {
-      return isValidStartBlockType(block?.type)
-    }) as any
-
-    if (!startBlock?.subBlocks?.inputFormat?.value) {
+    const inputFormat = extractInputFormatFromBlocks(normalizedData.blocks)
+    if (!inputFormat || inputFormat.length === 0) {
       return { type: 'object', properties: {} }
     }
 
-    const inputFormat = startBlock.subBlocks.inputFormat.value
-    if (!Array.isArray(inputFormat) || inputFormat.length === 0) {
-      return { type: 'object', properties: {} }
-    }
-
-    const properties: Record<string, { type: string; description: string }> = {}
-    const required: string[] = []
-
-    for (const field of inputFormat) {
-      if (!field?.name || typeof field.name !== 'string' || !field.name.trim()) continue
-
-      const fieldName = field.name.trim()
-      let jsonType = 'string'
-      switch (field.type) {
-        case 'number':
-          jsonType = 'number'
-          break
-        case 'boolean':
-          jsonType = 'boolean'
-          break
-        case 'object':
-          jsonType = 'object'
-          break
-        case 'array':
-        case 'files':
-          jsonType = 'array'
-          break
-        default:
-          jsonType = 'string'
-      }
-
-      properties[fieldName] = {
-        type: jsonType,
-        description: fieldName,
-      }
-      required.push(fieldName)
-    }
-
-    return {
-      type: 'object',
-      properties,
-      required: required.length > 0 ? required : undefined,
-    }
+    return generateToolInputSchema(inputFormat) as unknown as Record<string, unknown>
   } catch (error) {
     logger.warn('Error generating MCP tool schema:', error)
     return { type: 'object', properties: {} }

apps/sim/app/api/workflows/[id]/deploy/route.ts

@@ -3,11 +3,12 @@ import { and, eq } from 'drizzle-orm'
 import type { NextRequest } from 'next/server'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { createLogger } from '@/lib/logs/console/logger'
-import { validateWorkflowPermissions } from '@/lib/workflows/utils'
 import {
-  hasValidStartBlockInState,
-  isValidStartBlockType,
-} from '@/lib/workflows/triggers/trigger-utils'
+  extractInputFormatFromBlocks,
+  generateToolInputSchema,
+} from '@/lib/mcp/workflow-tool-schema'
+import { hasValidStartBlockInState } from '@/lib/workflows/triggers/trigger-utils'
+import { validateWorkflowPermissions } from '@/lib/workflows/utils'
 import { createErrorResponse, createSuccessResponse } from '@/app/api/workflows/utils'
 
 const logger = createLogger('WorkflowActivateDeploymentAPI')
@@ -24,58 +25,12 @@ function generateMcpToolSchemaFromState(state: any): Record<string, unknown> {
       return { type: 'object', properties: {} }
     }
 
-    // Find the start block in the deployed state
-    const startBlock = Object.values(state.blocks).find((block: any) => {
-      return isValidStartBlockType(block?.type)
-    }) as any
-
-    if (!startBlock?.subBlocks?.inputFormat?.value) {
-      return { type: 'object', properties: {} }
-    }
-
-    const inputFormat = startBlock.subBlocks.inputFormat.value
-    if (!Array.isArray(inputFormat) || inputFormat.length === 0) {
+    const inputFormat = extractInputFormatFromBlocks(state.blocks)
+    if (!inputFormat || inputFormat.length === 0) {
       return { type: 'object', properties: {} }
     }
 
-    const properties: Record<string, { type: string; description: string }> = {}
-    const required: string[] = []
-
-    for (const field of inputFormat) {
-      if (!field?.name || typeof field.name !== 'string' || !field.name.trim()) continue
-
-      const fieldName = field.name.trim()
-      let jsonType = 'string'
-      switch (field.type) {
-        case 'number':
-          jsonType = 'number'
-          break
-        case 'boolean':
-          jsonType = 'boolean'
-          break
-        case 'object':
-          jsonType = 'object'
-          break
-        case 'array':
-        case 'files':
-          jsonType = 'array'
-          break
-        default:
-          jsonType = 'string'
-      }
-
-      properties[fieldName] = {
-        type: jsonType,
-        description: fieldName,
-      }
-      required.push(fieldName)
-    }
-
-    return {
-      type: 'object',
-      properties,
-      required: required.length > 0 ? required : undefined,
-    }
+    return generateToolInputSchema(inputFormat) as unknown as Record<string, unknown>
   } catch (error) {
     logger.warn('Error generating MCP tool schema from state:', error)
     return { type: 'object', properties: {} }

apps/sim/app/api/workflows/[id]/deployments/[version]/activate/route.ts

@@ -4,12 +4,13 @@ import type { NextRequest } from 'next/server'
 import { env } from '@/lib/core/config/env'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { createLogger } from '@/lib/logs/console/logger'
+import {
+  extractInputFormatFromBlocks,
+  generateToolInputSchema,
+} from '@/lib/mcp/workflow-tool-schema'
 import { saveWorkflowToNormalizedTables } from '@/lib/workflows/persistence/utils'
+import { hasValidStartBlockInState } from '@/lib/workflows/triggers/trigger-utils'
 import { validateWorkflowPermissions } from '@/lib/workflows/utils'
-import {
-  hasValidStartBlockInState,
-  isValidStartBlockType,
-} from '@/lib/workflows/triggers/trigger-utils'
 import { createErrorResponse, createSuccessResponse } from '@/app/api/workflows/utils'
 
 const logger = createLogger('RevertToDeploymentVersionAPI')
@@ -26,58 +27,12 @@ function generateMcpToolSchemaFromState(state: any): Record<string, unknown> {
       return { type: 'object', properties: {} }
     }
 
-    // Find the start block in the deployed state
-    const startBlock = Object.values(state.blocks).find((block: any) => {
-      return isValidStartBlockType(block?.type)
-    }) as any
-
-    if (!startBlock?.subBlocks?.inputFormat?.value) {
+    const inputFormat = extractInputFormatFromBlocks(state.blocks)
+    if (!inputFormat || inputFormat.length === 0) {
       return { type: 'object', properties: {} }
     }
 
-    const inputFormat = startBlock.subBlocks.inputFormat.value
-    if (!Array.isArray(inputFormat) || inputFormat.length === 0) {
-      return { type: 'object', properties: {} }
-    }
-
-    const properties: Record<string, { type: string; description: string }> = {}
-    const required: string[] = []
-
-    for (const field of inputFormat) {
-      if (!field?.name || typeof field.name !== 'string' || !field.name.trim()) continue
-
-      const fieldName = field.name.trim()
-      let jsonType = 'string'
-      switch (field.type) {
-        case 'number':
-          jsonType = 'number'
-          break
-        case 'boolean':
-          jsonType = 'boolean'
-          break
-        case 'object':
-          jsonType = 'object'
-          break
-        case 'array':
-        case 'files':
-          jsonType = 'array'
-          break
-        default:
-          jsonType = 'string'
-      }
-
-      properties[fieldName] = {
-        type: jsonType,
-        description: fieldName,
-      }
-      required.push(fieldName)
-    }
-
-    return {
-      type: 'object',
-      properties,
-      required: required.length > 0 ? required : undefined,
-    }
+    return generateToolInputSchema(inputFormat) as unknown as Record<string, unknown>
   } catch (error) {
     logger.warn('Error generating MCP tool schema from state:', error)
     return { type: 'object', properties: {} }

apps/sim/app/api/workflows/[id]/deployments/[version]/revert/route.ts

@@ -118,11 +118,18 @@ function extractInputFormat(
 
 /**
  * Generate JSON Schema from input format using the shared utility
+ * Optionally applies custom descriptions from the UI
  */
 function generateParameterSchema(
-  inputFormat: Array<{ name: string; type: string }>
+  inputFormat: Array<{ name: string; type: string }>,
+  customDescriptions?: Record<string, string>
 ): Record<string, unknown> {
-  return generateToolInputSchema(inputFormat) as unknown as Record<string, unknown>
+  // Convert to InputFormatField with descriptions
+  const fieldsWithDescriptions = inputFormat.map((field) => ({
+    ...field,
+    description: customDescriptions?.[field.name]?.trim() || undefined,
+  }))
+  return generateToolInputSchema(fieldsWithDescriptions) as unknown as Record<string, unknown>
 }
 
 /**
@@ -461,13 +468,18 @@ export function McpToolDeploy({
     return extractInputFormat(blocks)
   }, [starterBlockId, subBlockValues, blocks])
 
-  const parameterSchema = useMemo(() => generateParameterSchema(inputFormat), [inputFormat])
-
   const [selectedServer, setSelectedServer] = useState<WorkflowMcpServer | null>(null)
   const [toolName, setToolName] = useState('')
   const [toolDescription, setToolDescription] = useState('')
   const [showServerSelector, setShowServerSelector] = useState(false)
   const [showParameterSchema, setShowParameterSchema] = useState(false)
+  // Track custom descriptions for each parameter
+  const [parameterDescriptions, setParameterDescriptions] = useState<Record<string, string>>({})
+
+  const parameterSchema = useMemo(
+    () => generateParameterSchema(inputFormat, parameterDescriptions),
+    [inputFormat, parameterDescriptions]
+  )
 
   // Track tools data from each server using state instead of hooks in a loop
   const [serverToolsMap, setServerToolsMap] = useState<
@@ -509,6 +521,32 @@ export function McpToolDeploy({
     return serversWithThisWorkflow.filter(({ tool }) => hasParameterMismatch(tool, inputFormat))
   }, [serversWithThisWorkflow, inputFormat])
 
+  // Load existing parameter descriptions from the first deployed tool
+  useEffect(() => {
+    if (serversWithThisWorkflow.length > 0) {
+      const existingTool = serversWithThisWorkflow[0].tool
+      const schema = existingTool.parameterSchema as Record<string, unknown> | undefined
+      const properties = schema?.properties as Record<string, { description?: string }> | undefined
+
+      if (properties) {
+        const descriptions: Record<string, string> = {}
+        for (const [name, prop] of Object.entries(properties)) {
+          // Only use description if it differs from the field name (i.e., it's custom)
+          if (
+            prop.description &&
+            prop.description !== name &&
+            prop.description !== 'Array of file objects'
+          ) {
+            descriptions[name] = prop.description
+          }
+        }
+        if (Object.keys(descriptions).length > 0) {
+          setParameterDescriptions(descriptions)
+        }
+      }
+    }
+  }, [serversWithThisWorkflow])
+
   // Reset form when selected server changes
   useEffect(() => {
     if (selectedServer) {
@@ -668,17 +706,33 @@ export function McpToolDeploy({
                 parameters.
               </p>
             ) : (
-              <div className='flex flex-col gap-[8px]'>
+              <div className='flex flex-col gap-[12px]'>
                 {inputFormat.map((field, index) => (
-                  <div key={index} className='flex items-center justify-between'>
-                    <span className='font-mono text-[12px] text-[var(--text-primary)]'>
-                      {field.name}
-                    </span>
-                    <Badge variant='outline' className='text-[10px]'>
-                      {field.type}
-                    </Badge>
+                  <div key={index} className='flex flex-col gap-[6px]'>
+                    <div className='flex items-center justify-between'>
+                      <span className='font-mono text-[12px] text-[var(--text-primary)]'>
+                        {field.name}
+                      </span>
+                      <Badge variant='outline' className='text-[10px]'>
+                        {field.type}
+                      </Badge>
+                    </div>
+                    <EmcnInput
+                      value={parameterDescriptions[field.name] || ''}
+                      onChange={(e) =>
+                        setParameterDescriptions((prev) => ({
+                          ...prev,
+                          [field.name]: e.target.value,
+                        }))
+                      }
+                      placeholder={`Describe what "${field.name}" is for...`}
+                      className='h-[32px] text-[12px]'
+                    />
                   </div>
                 ))}
+                <p className='text-[11px] text-[var(--text-muted)]'>
+                  Descriptions help MCP clients understand what each parameter is for.
+                </p>
               </div>
             )}
           </div>