Function syncMcpToolsForWorkflow

apps/sim/lib/mcp/workflow-mcp-sync.ts:183–320

(
  options: SyncOptions
)

 * @param options.context - Optional context for log messages
 */
export async function syncMcpToolsForWorkflow(
  options: SyncOptions
): Promise<Array<{ serverId: string }>> {
  if (!options.tx) {
    let state = options.state
    if (!state) {
      try {
        state = await loadDeployedWorkflowState(options.workflowId)
      } catch (error) {
        logger.error(
          `[${options.requestId}] Error loading deployed state for MCP tool sync (${options.context ?? 'sync'}):`,
          error
        )
        if (options.throwOnError) throw error
        return []
      }
    }
    const resolvedState = state
    const tools = await db.transaction((tx) =>
      syncMcpToolsForWorkflow({ ...options, state: resolvedState, tx, notify: false })
    )
    if (options.notify ?? true) notifyMcpToolServers(tools)
    return tools
  }

  const { workflowId, requestId, state, context = 'sync', tx, throwOnError = false } = options

  try {
    if (!hasValidStartBlockInState(state as WorkflowState | null)) {
      return await removeMcpToolsForWorkflow(workflowId, requestId, tx, true)
    }

    const generatedParameterSchema = state.blocks
      ? generateSchemaFromBlocks(state.blocks)
      : EMPTY_SCHEMA
    const schemaLimitError = validateMcpToolMetadataForStorage({
      parameterSchema: generatedParameterSchema,
    })
    if (schemaLimitError) {
      throw new Error(schemaLimitError)
    }
    const baseParameterSchema = generatedParameterSchema

    const affectedServerIds = new Set<string>()
    const lockedServers = await collectWorkflowMcpToolServerIds(tx, workflowId)
    if (lockedServers.length === 0) return []

    for (const { serverId } of lockedServers) {
      await acquireWorkflowMcpServerLock(tx, serverId)
      affectedServerIds.add(serverId)
    }
    const lockedServerIds = [...affectedServerIds]

    const usageStateByServer = new Map<string, ServerMetadataUsageState>()
    for (const { serverId } of lockedServers) {
      const rows = await getMcpServerToolMetadataUsageRows(tx, serverId)
      usageStateByServer.set(serverId, {
        usageByToolId: new Map(rows.map((row) => [row.id, row])),